@coinbase/cdp-sdk 1.15.0 → 1.17.0

package/_types/policies/schema.d.ts

@@ -140,6 +140,423 @@ export declare const EvmMessageCriterionSchema: z.ZodObject<{
     match: string;
 }>;
 export type EvmMessageCriterion = z.infer<typeof EvmMessageCriterionSchema>;
+/**
+ * A list of comparables to apply against encoded arguments in the transaction's `data` field.
+ */
+export declare const EvmDataParameterConditionListSchema: z.ZodObject<{
+    /**
+     * The name of the parameter to check against a transaction's calldata.
+     * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+     */
+    name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    /**
+     * The operator to use for the comparison. The value resolved at the `name` will be on the
+     * left-hand side of the operator, and the `values` field will be on the right-hand side.
+     */
+    operator: z.ZodEnum<["in", "not in"]>;
+    /**
+     * Values to compare against the resolved `name` value.
+     * All values are encoded as strings. Refer to the table in the documentation for how values
+     * should be encoded, and which operators are supported for each type.
+     */
+    values: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    values: string[];
+    name: string;
+    operator: "in" | "not in";
+}, {
+    values: string[];
+    name: string;
+    operator: "in" | "not in";
+}>;
+export type EvmDataParameterConditionList = z.infer<typeof EvmDataParameterConditionListSchema>;
+/**
+ * A single condition to apply against encoded arguments in the transaction's `data` field.
+ */
+export declare const EvmDataParameterConditionSchema: z.ZodObject<{
+    /**
+     * The name of the parameter to check against a transaction's calldata.
+     * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+     */
+    name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    /**
+     * The operator to use for the comparison. The value resolved at the `name` will be on the
+     * left-hand side of the operator, and the `value` field will be on the right-hand side.
+     */
+    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    /**
+     * A single value to compare the value resolved at `name` to.
+     * All values are encoded as strings. Refer to the table in the documentation for how values
+     * should be encoded, and which operators are supported for each type.
+     */
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    value: string;
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}, {
+    name: string;
+    value: string;
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}>;
+export type EvmDataParameterCondition = z.infer<typeof EvmDataParameterConditionSchema>;
+/**
+ * A single condition to apply against the function and encoded arguments in the transaction's `data` field.
+ * Each `parameter` configuration must be successfully evaluated against the corresponding function argument
+ * in order for a policy to be accepted.
+ */
+export declare const EvmDataConditionSchema: z.ZodObject<{
+    /**
+     * The name of a smart contract function being called.
+     */
+    function: z.ZodString;
+    /**
+     * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+     */
+    params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        /**
+         * The name of the parameter to check against a transaction's calldata.
+         * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+         */
+        name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        /**
+         * The operator to use for the comparison. The value resolved at the `name` will be on the
+         * left-hand side of the operator, and the `value` field will be on the right-hand side.
+         */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+        /**
+         * A single value to compare the value resolved at `name` to.
+         * All values are encoded as strings. Refer to the table in the documentation for how values
+         * should be encoded, and which operators are supported for each type.
+         */
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        value: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }, {
+        name: string;
+        value: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }>, z.ZodObject<{
+        /**
+         * The name of the parameter to check against a transaction's calldata.
+         * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+         */
+        name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        /**
+         * The operator to use for the comparison. The value resolved at the `name` will be on the
+         * left-hand side of the operator, and the `values` field will be on the right-hand side.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+        /**
+         * Values to compare against the resolved `name` value.
+         * All values are encoded as strings. Refer to the table in the documentation for how values
+         * should be encoded, and which operators are supported for each type.
+         */
+        values: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        values: string[];
+        name: string;
+        operator: "in" | "not in";
+    }, {
+        values: string[];
+        name: string;
+        operator: "in" | "not in";
+    }>]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    function: string;
+    params?: ({
+        values: string[];
+        name: string;
+        operator: "in" | "not in";
+    } | {
+        name: string;
+        value: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    })[] | undefined;
+}, {
+    function: string;
+    params?: ({
+        values: string[];
+        name: string;
+        operator: "in" | "not in";
+    } | {
+        name: string;
+        value: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    })[] | undefined;
+}>;
+export type EvmDataCondition = z.infer<typeof EvmDataConditionSchema>;
+/**
+ * Schema for EVM data criterion
+ */
+export declare const EvmDataCriterionSchema: z.ZodObject<{
+    /** The type of criterion, must be "evmData" for EVM transaction rules. */
+    type: z.ZodLiteral<"evmData">;
+    /**
+     * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+     */
+    abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
+    }, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"event">;
+        anonymous: z.ZodOptional<z.ZodBoolean>;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiEventParameter[];
+        type: "event";
+        name: string;
+        anonymous?: boolean | undefined;
+    }, {
+        inputs: readonly import("abitype").AbiEventParameter[];
+        type: "event";
+        name: string;
+        anonymous?: boolean | undefined;
+    }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+        constant: z.ZodOptional<z.ZodBoolean>;
+        gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+        payable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    }, {
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        name: z.ZodString;
+        outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    }, {
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"constructor">;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    }, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"fallback">;
+        inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+        stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    }, {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"receive">;
+        stateMutability: z.ZodLiteral<"payable">;
+    }, "strip", z.ZodTypeAny, {
+        type: "receive";
+        stateMutability: "payable";
+    }, {
+        type: "receive";
+        stateMutability: "payable";
+    }>]>>, {
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    } & ({
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    } | {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    } | {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    } | {
+        type: "receive";
+        stateMutability: "payable";
+    }), unknown>]>, "many">>]>;
+    /**
+     * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+     * Each condition must be met in order for this policy to be accepted or rejected.
+     */
+    conditions: z.ZodArray<z.ZodObject<{
+        /**
+         * The name of a smart contract function being called.
+         */
+        function: z.ZodString;
+        /**
+         * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+         */
+        params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            /**
+             * The name of the parameter to check against a transaction's calldata.
+             * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+             */
+            name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+            /**
+             * The operator to use for the comparison. The value resolved at the `name` will be on the
+             * left-hand side of the operator, and the `value` field will be on the right-hand side.
+             */
+            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+            /**
+             * A single value to compare the value resolved at `name` to.
+             * All values are encoded as strings. Refer to the table in the documentation for how values
+             * should be encoded, and which operators are supported for each type.
+             */
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }>, z.ZodObject<{
+            /**
+             * The name of the parameter to check against a transaction's calldata.
+             * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+             */
+            name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+            /**
+             * The operator to use for the comparison. The value resolved at the `name` will be on the
+             * left-hand side of the operator, and the `values` field will be on the right-hand side.
+             */
+            operator: z.ZodEnum<["in", "not in"]>;
+            /**
+             * Values to compare against the resolved `name` value.
+             * All values are encoded as strings. Refer to the table in the documentation for how values
+             * should be encoded, and which operators are supported for each type.
+             */
+            values: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }>]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }, {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "evmData";
+    abi: "erc20" | "erc721" | "erc1155" | readonly ({
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
+    } | {
+        inputs: readonly import("abitype").AbiEventParameter[];
+        type: "event";
+        name: string;
+        anonymous?: boolean | undefined;
+    } | ({
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    } & ({
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    } | {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    } | {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    } | {
+        type: "receive";
+        stateMutability: "payable";
+    })))[];
+    conditions: {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }[];
+}, {
+    type: "evmData";
+    abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+    conditions: {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }[];
+}>;
+export type EvmDataCriterion = z.infer<typeof EvmDataCriterionSchema>;
 /**
  * Schema for Solana address criterions
  */
@@ -211,6 +628,270 @@ export declare const SignEvmTransactionCriteriaSchema: z.ZodArray<z.ZodDiscrimin
     type: "evmAddress";
     operator: "in" | "not in";
     addresses: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "evmData" for EVM transaction rules. */
+    type: z.ZodLiteral<"evmData">;
+    /**
+     * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+     */
+    abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
+    }, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"event">;
+        anonymous: z.ZodOptional<z.ZodBoolean>;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiEventParameter[];
+        type: "event";
+        name: string;
+        anonymous?: boolean | undefined;
+    }, {
+        inputs: readonly import("abitype").AbiEventParameter[];
+        type: "event";
+        name: string;
+        anonymous?: boolean | undefined;
+    }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+        constant: z.ZodOptional<z.ZodBoolean>;
+        gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+        payable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    }, {
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        name: z.ZodString;
+        outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    }, {
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"constructor">;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    }, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"fallback">;
+        inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+        stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    }, {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"receive">;
+        stateMutability: z.ZodLiteral<"payable">;
+    }, "strip", z.ZodTypeAny, {
+        type: "receive";
+        stateMutability: "payable";
+    }, {
+        type: "receive";
+        stateMutability: "payable";
+    }>]>>, {
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    } & ({
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    } | {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    } | {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    } | {
+        type: "receive";
+        stateMutability: "payable";
+    }), unknown>]>, "many">>]>;
+    /**
+     * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+     * Each condition must be met in order for this policy to be accepted or rejected.
+     */
+    conditions: z.ZodArray<z.ZodObject<{
+        /**
+         * The name of a smart contract function being called.
+         */
+        function: z.ZodString;
+        /**
+         * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+         */
+        params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            /**
+             * The name of the parameter to check against a transaction's calldata.
+             * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+             */
+            name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+            /**
+             * The operator to use for the comparison. The value resolved at the `name` will be on the
+             * left-hand side of the operator, and the `value` field will be on the right-hand side.
+             */
+            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+            /**
+             * A single value to compare the value resolved at `name` to.
+             * All values are encoded as strings. Refer to the table in the documentation for how values
+             * should be encoded, and which operators are supported for each type.
+             */
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }>, z.ZodObject<{
+            /**
+             * The name of the parameter to check against a transaction's calldata.
+             * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+             */
+            name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+            /**
+             * The operator to use for the comparison. The value resolved at the `name` will be on the
+             * left-hand side of the operator, and the `values` field will be on the right-hand side.
+             */
+            operator: z.ZodEnum<["in", "not in"]>;
+            /**
+             * Values to compare against the resolved `name` value.
+             * All values are encoded as strings. Refer to the table in the documentation for how values
+             * should be encoded, and which operators are supported for each type.
+             */
+            values: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }>]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }, {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "evmData";
+    abi: "erc20" | "erc721" | "erc1155" | readonly ({
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
+    } | {
+        inputs: readonly import("abitype").AbiEventParameter[];
+        type: "event";
+        name: string;
+        anonymous?: boolean | undefined;
+    } | ({
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    } & ({
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    } | {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    } | {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    } | {
+        type: "receive";
+        stateMutability: "payable";
+    })))[];
+    conditions: {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }[];
+}, {
+    type: "evmData";
+    abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+    conditions: {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }[];
 }>]>, "many">;
 /**
  * Type representing a set of criteria for the signEvmTransaction operation.
@@ -303,14 +984,274 @@ export declare const SendEvmTransactionCriteriaSchema: z.ZodArray<z.ZodDiscrimin
     operator: "in" | "not in";
     networks: ("base-sepolia" | "base")[];
 }, {
-    type: "evmNetwork";
-    operator: "in" | "not in";
-    networks: ("base-sepolia" | "base")[];
+    type: "evmNetwork";
+    operator: "in" | "not in";
+    networks: ("base-sepolia" | "base")[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "evmData" for EVM transaction rules. */
+    type: z.ZodLiteral<"evmData">;
+    /**
+     * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+     */
+    abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
+    }, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"event">;
+        anonymous: z.ZodOptional<z.ZodBoolean>;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiEventParameter[];
+        type: "event";
+        name: string;
+        anonymous?: boolean | undefined;
+    }, {
+        inputs: readonly import("abitype").AbiEventParameter[];
+        type: "event";
+        name: string;
+        anonymous?: boolean | undefined;
+    }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+        constant: z.ZodOptional<z.ZodBoolean>;
+        gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+        payable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    }, {
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        name: z.ZodString;
+        outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    }, {
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"constructor">;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+        stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+    }, "strip", z.ZodTypeAny, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    }, {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"fallback">;
+        inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+        stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    }, {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"receive">;
+        stateMutability: z.ZodLiteral<"payable">;
+    }, "strip", z.ZodTypeAny, {
+        type: "receive";
+        stateMutability: "payable";
+    }, {
+        type: "receive";
+        stateMutability: "payable";
+    }>]>>, {
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    } & ({
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    } | {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    } | {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    } | {
+        type: "receive";
+        stateMutability: "payable";
+    }), unknown>]>, "many">>]>;
+    /**
+     * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+     * Each condition must be met in order for this policy to be accepted or rejected.
+     */
+    conditions: z.ZodArray<z.ZodObject<{
+        /**
+         * The name of a smart contract function being called.
+         */
+        function: z.ZodString;
+        /**
+         * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+         */
+        params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            /**
+             * The name of the parameter to check against a transaction's calldata.
+             * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+             */
+            name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+            /**
+             * The operator to use for the comparison. The value resolved at the `name` will be on the
+             * left-hand side of the operator, and the `value` field will be on the right-hand side.
+             */
+            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+            /**
+             * A single value to compare the value resolved at `name` to.
+             * All values are encoded as strings. Refer to the table in the documentation for how values
+             * should be encoded, and which operators are supported for each type.
+             */
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }>, z.ZodObject<{
+            /**
+             * The name of the parameter to check against a transaction's calldata.
+             * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+             */
+            name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+            /**
+             * The operator to use for the comparison. The value resolved at the `name` will be on the
+             * left-hand side of the operator, and the `values` field will be on the right-hand side.
+             */
+            operator: z.ZodEnum<["in", "not in"]>;
+            /**
+             * Values to compare against the resolved `name` value.
+             * All values are encoded as strings. Refer to the table in the documentation for how values
+             * should be encoded, and which operators are supported for each type.
+             */
+            values: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }>]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }, {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "evmData";
+    abi: "erc20" | "erc721" | "erc1155" | readonly ({
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
+    } | {
+        inputs: readonly import("abitype").AbiEventParameter[];
+        type: "event";
+        name: string;
+        anonymous?: boolean | undefined;
+    } | ({
+        payable?: boolean | undefined;
+        constant?: boolean | undefined;
+        gas?: number | undefined;
+    } & ({
+        inputs: readonly import("abitype").AbiParameter[];
+        outputs: readonly import("abitype").AbiParameter[];
+        type: "function";
+        name: string;
+        stateMutability: "pure" | "view" | "nonpayable" | "payable";
+    } | {
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "constructor";
+        stateMutability: "nonpayable" | "payable";
+    } | {
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
+    } | {
+        type: "receive";
+        stateMutability: "payable";
+    })))[];
+    conditions: {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }[];
+}, {
+    type: "evmData";
+    abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+    conditions: {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            name: string;
+            value: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }[];
 }>]>, "many">;
-/**
- * Type representing a set of criteria for the sendEvmTransaction operation.
- * Can contain up to 10 individual criterion objects of ETH value or EVM address types.
- */
 export type SendEvmTransactionCriteria = z.infer<typeof SendEvmTransactionCriteriaSchema>;
 /**
  * Schema for criteria used in SignSolTransaction operations
@@ -430,6 +1371,270 @@ export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmData" for EVM transaction rules. */
+        type: z.ZodLiteral<"evmData">;
+        /**
+         * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+         */
+        abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"error">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"event">;
+            anonymous: z.ZodOptional<z.ZodBoolean>;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        }, {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+            constant: z.ZodOptional<z.ZodBoolean>;
+            gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+            payable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        }, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            name: z.ZodString;
+            outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"constructor">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"fallback">;
+            inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        }, {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"receive">;
+            stateMutability: z.ZodLiteral<"payable">;
+        }, "strip", z.ZodTypeAny, {
+            type: "receive";
+            stateMutability: "payable";
+        }, {
+            type: "receive";
+            stateMutability: "payable";
+        }>]>>, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        }), unknown>]>, "many">>]>;
+        /**
+         * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+         * Each condition must be met in order for this policy to be accepted or rejected.
+         */
+        conditions: z.ZodArray<z.ZodObject<{
+            /**
+             * The name of a smart contract function being called.
+             */
+            function: z.ZodString;
+            /**
+             * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+             */
+            params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                /**
+                 * The name of the parameter to check against a transaction's calldata.
+                 * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                 */
+                name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                /**
+                 * The operator to use for the comparison. The value resolved at the `name` will be on the
+                 * left-hand side of the operator, and the `value` field will be on the right-hand side.
+                 */
+                operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                /**
+                 * A single value to compare the value resolved at `name` to.
+                 * All values are encoded as strings. Refer to the table in the documentation for how values
+                 * should be encoded, and which operators are supported for each type.
+                 */
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }, {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }>, z.ZodObject<{
+                /**
+                 * The name of the parameter to check against a transaction's calldata.
+                 * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                 */
+                name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                /**
+                 * The operator to use for the comparison. The value resolved at the `name` will be on the
+                 * left-hand side of the operator, and the `values` field will be on the right-hand side.
+                 */
+                operator: z.ZodEnum<["in", "not in"]>;
+                /**
+                 * Values to compare against the resolved `name` value.
+                 * All values are encoded as strings. Refer to the table in the documentation for how values
+                 * should be encoded, and which operators are supported for each type.
+                 */
+                values: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }>]>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly ({
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        } | {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        } | ({
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        })))[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    }, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
@@ -442,6 +1647,51 @@ export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: `0x${string}`[];
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly ({
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        } | {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        } | ({
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        })))[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     })[];
 }, {
     action: "reject" | "accept";
@@ -454,6 +1704,21 @@ export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     })[];
 }>;
 export type SignEvmTransactionRule = z.infer<typeof SignEvmTransactionRuleSchema>;
@@ -612,6 +1877,270 @@ export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmNetwork";
         operator: "in" | "not in";
         networks: ("base-sepolia" | "base")[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmData" for EVM transaction rules. */
+        type: z.ZodLiteral<"evmData">;
+        /**
+         * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+         */
+        abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"error">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"event">;
+            anonymous: z.ZodOptional<z.ZodBoolean>;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        }, {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+            constant: z.ZodOptional<z.ZodBoolean>;
+            gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+            payable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        }, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            name: z.ZodString;
+            outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"constructor">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"fallback">;
+            inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        }, {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"receive">;
+            stateMutability: z.ZodLiteral<"payable">;
+        }, "strip", z.ZodTypeAny, {
+            type: "receive";
+            stateMutability: "payable";
+        }, {
+            type: "receive";
+            stateMutability: "payable";
+        }>]>>, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        }), unknown>]>, "many">>]>;
+        /**
+         * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+         * Each condition must be met in order for this policy to be accepted or rejected.
+         */
+        conditions: z.ZodArray<z.ZodObject<{
+            /**
+             * The name of a smart contract function being called.
+             */
+            function: z.ZodString;
+            /**
+             * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+             */
+            params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                /**
+                 * The name of the parameter to check against a transaction's calldata.
+                 * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                 */
+                name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                /**
+                 * The operator to use for the comparison. The value resolved at the `name` will be on the
+                 * left-hand side of the operator, and the `value` field will be on the right-hand side.
+                 */
+                operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                /**
+                 * A single value to compare the value resolved at `name` to.
+                 * All values are encoded as strings. Refer to the table in the documentation for how values
+                 * should be encoded, and which operators are supported for each type.
+                 */
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }, {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }>, z.ZodObject<{
+                /**
+                 * The name of the parameter to check against a transaction's calldata.
+                 * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                 */
+                name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                /**
+                 * The operator to use for the comparison. The value resolved at the `name` will be on the
+                 * left-hand side of the operator, and the `values` field will be on the right-hand side.
+                 */
+                operator: z.ZodEnum<["in", "not in"]>;
+                /**
+                 * Values to compare against the resolved `name` value.
+                 * All values are encoded as strings. Refer to the table in the documentation for how values
+                 * should be encoded, and which operators are supported for each type.
+                 */
+                values: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }>]>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly ({
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        } | {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        } | ({
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        })))[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    }, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
@@ -628,6 +2157,51 @@ export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmNetwork";
         operator: "in" | "not in";
         networks: ("base-sepolia" | "base")[];
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly ({
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        } | {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        } | ({
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        })))[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     })[];
 }, {
     action: "reject" | "accept";
@@ -644,6 +2218,21 @@ export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmNetwork";
         operator: "in" | "not in";
         networks: ("base-sepolia" | "base")[];
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     })[];
 }>;
 export type SendEvmTransactionRule = z.infer<typeof SendEvmTransactionRuleSchema>;
@@ -766,6 +2355,270 @@ export declare const RuleSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObje
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmData" for EVM transaction rules. */
+        type: z.ZodLiteral<"evmData">;
+        /**
+         * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+         */
+        abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"error">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"event">;
+            anonymous: z.ZodOptional<z.ZodBoolean>;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        }, {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+            constant: z.ZodOptional<z.ZodBoolean>;
+            gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+            payable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        }, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            name: z.ZodString;
+            outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"constructor">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"fallback">;
+            inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        }, {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"receive">;
+            stateMutability: z.ZodLiteral<"payable">;
+        }, "strip", z.ZodTypeAny, {
+            type: "receive";
+            stateMutability: "payable";
+        }, {
+            type: "receive";
+            stateMutability: "payable";
+        }>]>>, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        }), unknown>]>, "many">>]>;
+        /**
+         * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+         * Each condition must be met in order for this policy to be accepted or rejected.
+         */
+        conditions: z.ZodArray<z.ZodObject<{
+            /**
+             * The name of a smart contract function being called.
+             */
+            function: z.ZodString;
+            /**
+             * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+             */
+            params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                /**
+                 * The name of the parameter to check against a transaction's calldata.
+                 * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                 */
+                name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                /**
+                 * The operator to use for the comparison. The value resolved at the `name` will be on the
+                 * left-hand side of the operator, and the `value` field will be on the right-hand side.
+                 */
+                operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                /**
+                 * A single value to compare the value resolved at `name` to.
+                 * All values are encoded as strings. Refer to the table in the documentation for how values
+                 * should be encoded, and which operators are supported for each type.
+                 */
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }, {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }>, z.ZodObject<{
+                /**
+                 * The name of the parameter to check against a transaction's calldata.
+                 * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                 */
+                name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                /**
+                 * The operator to use for the comparison. The value resolved at the `name` will be on the
+                 * left-hand side of the operator, and the `values` field will be on the right-hand side.
+                 */
+                operator: z.ZodEnum<["in", "not in"]>;
+                /**
+                 * Values to compare against the resolved `name` value.
+                 * All values are encoded as strings. Refer to the table in the documentation for how values
+                 * should be encoded, and which operators are supported for each type.
+                 */
+                values: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }>]>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly ({
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        } | {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        } | ({
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        })))[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    }, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
@@ -778,6 +2631,51 @@ export declare const RuleSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObje
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: `0x${string}`[];
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly ({
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        } | {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        } | ({
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        })))[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     })[];
 }, {
     action: "reject" | "accept";
@@ -790,6 +2688,21 @@ export declare const RuleSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObje
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     })[];
 }>, z.ZodObject<{
     /**
@@ -930,6 +2843,270 @@ export declare const RuleSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObje
         type: "evmNetwork";
         operator: "in" | "not in";
         networks: ("base-sepolia" | "base")[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmData" for EVM transaction rules. */
+        type: z.ZodLiteral<"evmData">;
+        /**
+         * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+         */
+        abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"error">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"event">;
+            anonymous: z.ZodOptional<z.ZodBoolean>;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        }, {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+            constant: z.ZodOptional<z.ZodBoolean>;
+            gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+            payable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        }, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            name: z.ZodString;
+            outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"constructor">;
+            inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+        }, "strip", z.ZodTypeAny, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        }, {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"fallback">;
+            inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+            stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        }, {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"receive">;
+            stateMutability: z.ZodLiteral<"payable">;
+        }, "strip", z.ZodTypeAny, {
+            type: "receive";
+            stateMutability: "payable";
+        }, {
+            type: "receive";
+            stateMutability: "payable";
+        }>]>>, {
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        }), unknown>]>, "many">>]>;
+        /**
+         * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+         * Each condition must be met in order for this policy to be accepted or rejected.
+         */
+        conditions: z.ZodArray<z.ZodObject<{
+            /**
+             * The name of a smart contract function being called.
+             */
+            function: z.ZodString;
+            /**
+             * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+             */
+            params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                /**
+                 * The name of the parameter to check against a transaction's calldata.
+                 * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                 */
+                name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                /**
+                 * The operator to use for the comparison. The value resolved at the `name` will be on the
+                 * left-hand side of the operator, and the `value` field will be on the right-hand side.
+                 */
+                operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                /**
+                 * A single value to compare the value resolved at `name` to.
+                 * All values are encoded as strings. Refer to the table in the documentation for how values
+                 * should be encoded, and which operators are supported for each type.
+                 */
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }, {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }>, z.ZodObject<{
+                /**
+                 * The name of the parameter to check against a transaction's calldata.
+                 * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                 */
+                name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                /**
+                 * The operator to use for the comparison. The value resolved at the `name` will be on the
+                 * left-hand side of the operator, and the `values` field will be on the right-hand side.
+                 */
+                operator: z.ZodEnum<["in", "not in"]>;
+                /**
+                 * Values to compare against the resolved `name` value.
+                 * All values are encoded as strings. Refer to the table in the documentation for how values
+                 * should be encoded, and which operators are supported for each type.
+                 */
+                values: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }>]>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly ({
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        } | {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        } | ({
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        })))[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    }, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
@@ -946,6 +3123,51 @@ export declare const RuleSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObje
         type: "evmNetwork";
         operator: "in" | "not in";
         networks: ("base-sepolia" | "base")[];
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly ({
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
+        } | {
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
+        } | ({
+            payable?: boolean | undefined;
+            constant?: boolean | undefined;
+            gas?: number | undefined;
+        } & ({
+            inputs: readonly import("abitype").AbiParameter[];
+            outputs: readonly import("abitype").AbiParameter[];
+            type: "function";
+            name: string;
+            stateMutability: "pure" | "view" | "nonpayable" | "payable";
+        } | {
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
+        } | {
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
+        } | {
+            type: "receive";
+            stateMutability: "payable";
+        })))[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     })[];
 }, {
     action: "reject" | "accept";
@@ -962,6 +3184,21 @@ export declare const RuleSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObje
         type: "evmNetwork";
         operator: "in" | "not in";
         networks: ("base-sepolia" | "base")[];
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                name: string;
+                value: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     })[];
 }>, z.ZodObject<{
     /**
@@ -1106,6 +3343,270 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             type: "evmAddress";
             operator: "in" | "not in";
             addresses: string[];
+        }>, z.ZodObject<{
+            /** The type of criterion, must be "evmData" for EVM transaction rules. */
+            type: z.ZodLiteral<"evmData">;
+            /**
+             * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+             */
+            abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"error">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"event">;
+                anonymous: z.ZodOptional<z.ZodBoolean>;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            }, {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+                constant: z.ZodOptional<z.ZodBoolean>;
+                gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+                payable: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            }, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                name: z.ZodString;
+                outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"constructor">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"fallback">;
+                inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            }, {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"receive">;
+                stateMutability: z.ZodLiteral<"payable">;
+            }, "strip", z.ZodTypeAny, {
+                type: "receive";
+                stateMutability: "payable";
+            }, {
+                type: "receive";
+                stateMutability: "payable";
+            }>]>>, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            }), unknown>]>, "many">>]>;
+            /**
+             * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+             * Each condition must be met in order for this policy to be accepted or rejected.
+             */
+            conditions: z.ZodArray<z.ZodObject<{
+                /**
+                 * The name of a smart contract function being called.
+                 */
+                function: z.ZodString;
+                /**
+                 * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+                 */
+                params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                    /**
+                     * The name of the parameter to check against a transaction's calldata.
+                     * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                     */
+                    name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                    /**
+                     * The operator to use for the comparison. The value resolved at the `name` will be on the
+                     * left-hand side of the operator, and the `value` field will be on the right-hand side.
+                     */
+                    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                    /**
+                     * A single value to compare the value resolved at `name` to.
+                     * All values are encoded as strings. Refer to the table in the documentation for how values
+                     * should be encoded, and which operators are supported for each type.
+                     */
+                    value: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                }, {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                }>, z.ZodObject<{
+                    /**
+                     * The name of the parameter to check against a transaction's calldata.
+                     * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                     */
+                    name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                    /**
+                     * The operator to use for the comparison. The value resolved at the `name` will be on the
+                     * left-hand side of the operator, and the `values` field will be on the right-hand side.
+                     */
+                    operator: z.ZodEnum<["in", "not in"]>;
+                    /**
+                     * Values to compare against the resolved `name` value.
+                     * All values are encoded as strings. Refer to the table in the documentation for how values
+                     * should be encoded, and which operators are supported for each type.
+                     */
+                    values: z.ZodArray<z.ZodString, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                }, {
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                }>]>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }, {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
+        }, {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         }>]>, "many">;
     }, "strip", z.ZodTypeAny, {
         action: "reject" | "accept";
@@ -1118,6 +3619,51 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             type: "evmAddress";
             operator: "in" | "not in";
             addresses: `0x${string}`[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     }, {
         action: "reject" | "accept";
@@ -1130,6 +3676,21 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             type: "evmAddress";
             operator: "in" | "not in";
             addresses: string[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     }>, z.ZodObject<{
         /**
@@ -1270,6 +3831,270 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             type: "evmNetwork";
             operator: "in" | "not in";
             networks: ("base-sepolia" | "base")[];
+        }>, z.ZodObject<{
+            /** The type of criterion, must be "evmData" for EVM transaction rules. */
+            type: z.ZodLiteral<"evmData">;
+            /**
+             * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+             */
+            abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"error">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"event">;
+                anonymous: z.ZodOptional<z.ZodBoolean>;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            }, {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+                constant: z.ZodOptional<z.ZodBoolean>;
+                gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+                payable: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            }, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                name: z.ZodString;
+                outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"constructor">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"fallback">;
+                inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            }, {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"receive">;
+                stateMutability: z.ZodLiteral<"payable">;
+            }, "strip", z.ZodTypeAny, {
+                type: "receive";
+                stateMutability: "payable";
+            }, {
+                type: "receive";
+                stateMutability: "payable";
+            }>]>>, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            }), unknown>]>, "many">>]>;
+            /**
+             * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+             * Each condition must be met in order for this policy to be accepted or rejected.
+             */
+            conditions: z.ZodArray<z.ZodObject<{
+                /**
+                 * The name of a smart contract function being called.
+                 */
+                function: z.ZodString;
+                /**
+                 * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+                 */
+                params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                    /**
+                     * The name of the parameter to check against a transaction's calldata.
+                     * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                     */
+                    name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                    /**
+                     * The operator to use for the comparison. The value resolved at the `name` will be on the
+                     * left-hand side of the operator, and the `value` field will be on the right-hand side.
+                     */
+                    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                    /**
+                     * A single value to compare the value resolved at `name` to.
+                     * All values are encoded as strings. Refer to the table in the documentation for how values
+                     * should be encoded, and which operators are supported for each type.
+                     */
+                    value: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                }, {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                }>, z.ZodObject<{
+                    /**
+                     * The name of the parameter to check against a transaction's calldata.
+                     * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                     */
+                    name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                    /**
+                     * The operator to use for the comparison. The value resolved at the `name` will be on the
+                     * left-hand side of the operator, and the `values` field will be on the right-hand side.
+                     */
+                    operator: z.ZodEnum<["in", "not in"]>;
+                    /**
+                     * Values to compare against the resolved `name` value.
+                     * All values are encoded as strings. Refer to the table in the documentation for how values
+                     * should be encoded, and which operators are supported for each type.
+                     */
+                    values: z.ZodArray<z.ZodString, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                }, {
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                }>]>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }, {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
+        }, {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         }>]>, "many">;
     }, "strip", z.ZodTypeAny, {
         action: "reject" | "accept";
@@ -1286,6 +4111,51 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             type: "evmNetwork";
             operator: "in" | "not in";
             networks: ("base-sepolia" | "base")[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     }, {
         action: "reject" | "accept";
@@ -1302,6 +4172,21 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             type: "evmNetwork";
             operator: "in" | "not in";
             networks: ("base-sepolia" | "base")[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     }>, z.ZodObject<{
         /**
@@ -1371,6 +4256,51 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             type: "evmAddress";
             operator: "in" | "not in";
             addresses: `0x${string}`[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     } | {
         action: "reject" | "accept";
@@ -1397,6 +4327,51 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             type: "evmNetwork";
             operator: "in" | "not in";
             networks: ("base-sepolia" | "base")[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     } | {
         action: "reject" | "accept";
@@ -1421,6 +4396,21 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             type: "evmAddress";
             operator: "in" | "not in";
             addresses: string[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     } | {
         action: "reject" | "accept";
@@ -1447,6 +4437,21 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             type: "evmNetwork";
             operator: "in" | "not in";
             networks: ("base-sepolia" | "base")[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     } | {
         action: "reject" | "accept";
@@ -1530,6 +4535,270 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             type: "evmAddress";
             operator: "in" | "not in";
             addresses: string[];
+        }>, z.ZodObject<{
+            /** The type of criterion, must be "evmData" for EVM transaction rules. */
+            type: z.ZodLiteral<"evmData">;
+            /**
+             * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+             */
+            abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"error">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"event">;
+                anonymous: z.ZodOptional<z.ZodBoolean>;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            }, {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+                constant: z.ZodOptional<z.ZodBoolean>;
+                gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+                payable: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            }, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                name: z.ZodString;
+                outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"constructor">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"fallback">;
+                inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            }, {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"receive">;
+                stateMutability: z.ZodLiteral<"payable">;
+            }, "strip", z.ZodTypeAny, {
+                type: "receive";
+                stateMutability: "payable";
+            }, {
+                type: "receive";
+                stateMutability: "payable";
+            }>]>>, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            }), unknown>]>, "many">>]>;
+            /**
+             * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+             * Each condition must be met in order for this policy to be accepted or rejected.
+             */
+            conditions: z.ZodArray<z.ZodObject<{
+                /**
+                 * The name of a smart contract function being called.
+                 */
+                function: z.ZodString;
+                /**
+                 * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+                 */
+                params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                    /**
+                     * The name of the parameter to check against a transaction's calldata.
+                     * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                     */
+                    name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                    /**
+                     * The operator to use for the comparison. The value resolved at the `name` will be on the
+                     * left-hand side of the operator, and the `value` field will be on the right-hand side.
+                     */
+                    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                    /**
+                     * A single value to compare the value resolved at `name` to.
+                     * All values are encoded as strings. Refer to the table in the documentation for how values
+                     * should be encoded, and which operators are supported for each type.
+                     */
+                    value: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                }, {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                }>, z.ZodObject<{
+                    /**
+                     * The name of the parameter to check against a transaction's calldata.
+                     * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                     */
+                    name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                    /**
+                     * The operator to use for the comparison. The value resolved at the `name` will be on the
+                     * left-hand side of the operator, and the `values` field will be on the right-hand side.
+                     */
+                    operator: z.ZodEnum<["in", "not in"]>;
+                    /**
+                     * Values to compare against the resolved `name` value.
+                     * All values are encoded as strings. Refer to the table in the documentation for how values
+                     * should be encoded, and which operators are supported for each type.
+                     */
+                    values: z.ZodArray<z.ZodString, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                }, {
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                }>]>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }, {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
+        }, {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         }>]>, "many">;
     }, "strip", z.ZodTypeAny, {
         action: "reject" | "accept";
@@ -1542,6 +4811,51 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             type: "evmAddress";
             operator: "in" | "not in";
             addresses: `0x${string}`[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     }, {
         action: "reject" | "accept";
@@ -1554,6 +4868,21 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             type: "evmAddress";
             operator: "in" | "not in";
             addresses: string[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     }>, z.ZodObject<{
         /**
@@ -1694,6 +5023,270 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             type: "evmNetwork";
             operator: "in" | "not in";
             networks: ("base-sepolia" | "base")[];
+        }>, z.ZodObject<{
+            /** The type of criterion, must be "evmData" for EVM transaction rules. */
+            type: z.ZodLiteral<"evmData">;
+            /**
+             * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+             */
+            abi: z.ZodUnion<[z.ZodEnum<["erc20", "erc721", "erc1155"]>, z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"error">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"event">;
+                anonymous: z.ZodOptional<z.ZodBoolean>;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            }, {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
+                constant: z.ZodOptional<z.ZodBoolean>;
+                gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+                payable: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            }, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                name: z.ZodString;
+                outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"constructor">;
+                inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+            }, "strip", z.ZodTypeAny, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            }, {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"fallback">;
+                inputs: z.ZodOptional<z.ZodTuple<[], null>>;
+                stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            }, {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"receive">;
+                stateMutability: z.ZodLiteral<"payable">;
+            }, "strip", z.ZodTypeAny, {
+                type: "receive";
+                stateMutability: "payable";
+            }, {
+                type: "receive";
+                stateMutability: "payable";
+            }>]>>, {
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            }), unknown>]>, "many">>]>;
+            /**
+             * A list of conditions to apply against the function and encoded arguments in the transaction's `data` field.
+             * Each condition must be met in order for this policy to be accepted or rejected.
+             */
+            conditions: z.ZodArray<z.ZodObject<{
+                /**
+                 * The name of a smart contract function being called.
+                 */
+                function: z.ZodString;
+                /**
+                 * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+                 */
+                params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                    /**
+                     * The name of the parameter to check against a transaction's calldata.
+                     * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                     */
+                    name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                    /**
+                     * The operator to use for the comparison. The value resolved at the `name` will be on the
+                     * left-hand side of the operator, and the `value` field will be on the right-hand side.
+                     */
+                    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                    /**
+                     * A single value to compare the value resolved at `name` to.
+                     * All values are encoded as strings. Refer to the table in the documentation for how values
+                     * should be encoded, and which operators are supported for each type.
+                     */
+                    value: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                }, {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                }>, z.ZodObject<{
+                    /**
+                     * The name of the parameter to check against a transaction's calldata.
+                     * If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter.
+                     */
+                    name: z.ZodUnion<[z.ZodString, z.ZodString]>;
+                    /**
+                     * The operator to use for the comparison. The value resolved at the `name` will be on the
+                     * left-hand side of the operator, and the `values` field will be on the right-hand side.
+                     */
+                    operator: z.ZodEnum<["in", "not in"]>;
+                    /**
+                     * Values to compare against the resolved `name` value.
+                     * All values are encoded as strings. Refer to the table in the documentation for how values
+                     * should be encoded, and which operators are supported for each type.
+                     */
+                    values: z.ZodArray<z.ZodString, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                }, {
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                }>]>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }, {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
+        }, {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         }>]>, "many">;
     }, "strip", z.ZodTypeAny, {
         action: "reject" | "accept";
@@ -1710,6 +5303,51 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             type: "evmNetwork";
             operator: "in" | "not in";
             networks: ("base-sepolia" | "base")[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     }, {
         action: "reject" | "accept";
@@ -1726,6 +5364,21 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             type: "evmNetwork";
             operator: "in" | "not in";
             networks: ("base-sepolia" | "base")[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     }>, z.ZodObject<{
         /**
@@ -1794,6 +5447,51 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             type: "evmAddress";
             operator: "in" | "not in";
             addresses: `0x${string}`[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     } | {
         action: "reject" | "accept";
@@ -1820,6 +5518,51 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             type: "evmNetwork";
             operator: "in" | "not in";
             networks: ("base-sepolia" | "base")[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly ({
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "error";
+                name: string;
+            } | {
+                inputs: readonly import("abitype").AbiEventParameter[];
+                type: "event";
+                name: string;
+                anonymous?: boolean | undefined;
+            } | ({
+                payable?: boolean | undefined;
+                constant?: boolean | undefined;
+                gas?: number | undefined;
+            } & ({
+                inputs: readonly import("abitype").AbiParameter[];
+                outputs: readonly import("abitype").AbiParameter[];
+                type: "function";
+                name: string;
+                stateMutability: "pure" | "view" | "nonpayable" | "payable";
+            } | {
+                inputs: readonly import("abitype").AbiParameter[];
+                type: "constructor";
+                stateMutability: "nonpayable" | "payable";
+            } | {
+                type: "fallback";
+                stateMutability: "nonpayable" | "payable";
+                inputs?: [] | undefined;
+            } | {
+                type: "receive";
+                stateMutability: "payable";
+            })))[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     } | {
         action: "reject" | "accept";
@@ -1843,6 +5586,21 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             type: "evmAddress";
             operator: "in" | "not in";
             addresses: string[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     } | {
         action: "reject" | "accept";
@@ -1869,6 +5627,21 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             type: "evmNetwork";
             operator: "in" | "not in";
             networks: ("base-sepolia" | "base")[];
+        } | {
+            type: "evmData";
+            abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+            conditions: {
+                function: string;
+                params?: ({
+                    values: string[];
+                    name: string;
+                    operator: "in" | "not in";
+                } | {
+                    name: string;
+                    value: string;
+                    operator: ">" | ">=" | "<" | "<=" | "==";
+                })[] | undefined;
+            }[];
         })[];
     } | {
         action: "reject" | "accept";