@coinbase/cdp-sdk 1.44.1 → 1.45.0

package/_types/policies/evmSchema.d.ts

@@ -113,11 +113,11 @@ export declare const SendEvmTransactionEvmNetworkCriterionSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "avalanche")[];
 }, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "avalanche")[];
 }>;
 export declare const PrepareUserOperationEvmNetworkCriterionSchema: z.ZodObject<{
     /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
@@ -136,11 +136,11 @@ export declare const PrepareUserOperationEvmNetworkCriterionSchema: z.ZodObject<
 }, "strip", z.ZodTypeAny, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "zora" | "polygon" | "bnb" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
 }, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "zora" | "polygon" | "bnb" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
 }>;
 export declare const EvmNetworkCriterionSchema: z.ZodUnion<[z.ZodObject<{
     /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
@@ -159,11 +159,11 @@ export declare const EvmNetworkCriterionSchema: z.ZodUnion<[z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "avalanche")[];
 }, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "avalanche")[];
 }>, z.ZodObject<{
     /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
     type: z.ZodLiteral<"evmNetwork">;
@@ -181,11 +181,11 @@ export declare const EvmNetworkCriterionSchema: z.ZodUnion<[z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "zora" | "polygon" | "bnb" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
 }, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "zora" | "polygon" | "bnb" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
 }>]>;
 export type EvmNetworkCriterion = z.ZodUnion<[
     typeof SendEvmTransactionEvmNetworkCriterionSchema,
@@ -1524,11 +1524,11 @@ export declare const SendEvmTransactionCriteriaSchema: z.ZodArray<z.ZodDiscrimin
 }, "strip", z.ZodTypeAny, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "avalanche")[];
 }, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "avalanche")[];
 }>, z.ZodObject<{
     /** The type of criterion, must be "evmData" for EVM transaction rules. */
     type: z.ZodLiteral<"evmData">;
@@ -1879,11 +1879,11 @@ export declare const PrepareUserOperationCriteriaSchema: z.ZodArray<z.ZodDiscrim
 }, "strip", z.ZodTypeAny, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "zora" | "polygon" | "bnb" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
 }, {
     type: "evmNetwork";
     operator: "in" | "not in";
-    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "zora" | "polygon" | "bnb" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
 }>, z.ZodObject<{
     /** The type of criterion, must be "evmData" for EVM transaction rules. */
     type: z.ZodLiteral<"evmData">;
@@ -2515,105 +2515,1794 @@ export declare const SendUserOperationCriteriaSchema: z.ZodArray<z.ZodDiscrimina
  */
 export type SendUserOperationCriteria = z.infer<typeof SendUserOperationCriteriaSchema>;
 /**
- * Enum for Evm Operation types
- */
-export declare const EvmOperationEnum: z.ZodEnum<["signEvmTransaction", "sendEvmTransaction", "signEvmMessage", "signEvmTypedData", "signEvmHash", "prepareUserOperation", "sendUserOperation"]>;
-/**
- * Type representing the operations that can be governed by a policy.
- * Defines what EVM operations the policy applies to.
- */
-export type EvmOperation = z.infer<typeof EvmOperationEnum>;
-/**
- * Enum for Action types
- */
-export declare const ActionEnum: z.ZodEnum<["reject", "accept"]>;
-/**
- * Type representing the possible policy actions.
- * Determines whether matching the rule will cause a request to be accepted or rejected.
- */
-export type Action = z.infer<typeof ActionEnum>;
-/**
- * Type representing a 'signEvmTransaction' policy rule that can accept or reject specific operations
- * based on a set of criteria.
+ * Schema for criteria used in SignEndUserEvmTransaction operations
  */
-export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
+export declare const SignEndUserEvmTransactionCriteriaSchema: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    /** The type of criterion, must be "ethValue" for Ethereum value-based rules. */
+    type: z.ZodLiteral<"ethValue">;
     /**
-     * Determines whether matching the rule will cause a request to be rejected or accepted.
-     * "accept" will allow the transaction, "reject" will block it.
+     * The ETH value amount in wei to compare against, as a string.
+     * Must contain only digits.
      */
-    action: z.ZodEnum<["reject", "accept"]>;
+    ethValue: z.ZodString;
+    /** The comparison operator to use for evaluating transaction values against the threshold. */
+    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+}, "strip", z.ZodTypeAny, {
+    ethValue: string;
+    type: "ethValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}, {
+    ethValue: string;
+    type: "ethValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}>, z.ZodObject<{
+    /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
+    type: z.ZodLiteral<"evmAddress">;
     /**
-     * The operation to which this rule applies.
-     * Must be "signEvmTransaction".
+     * Array of EVM addresses to compare against.
+     * Each address must be a 0x-prefixed 40-character hexadecimal string.
+     * Limited to a maximum of 300 addresses per criterion.
      */
-    operation: z.ZodLiteral<"signEvmTransaction">;
+    addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
     /**
-     * The set of criteria that must be matched for this rule to apply.
-     * Must be compatible with the specified operation type.
+     * The operator to use for evaluating transaction addresses.
+     * "in" checks if an address is in the provided list.
+     * "not in" checks if an address is not in the provided list.
      */
-    criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-        /** The type of criterion, must be "ethValue" for Ethereum value-based rules. */
-        type: z.ZodLiteral<"ethValue">;
-        /**
-         * The ETH value amount in wei to compare against, as a string.
-         * Must contain only digits.
-         */
-        ethValue: z.ZodString;
-        /** The comparison operator to use for evaluating transaction values against the threshold. */
-        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    operator: z.ZodEnum<["in", "not in"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "evmAddress";
+    operator: "in" | "not in";
+    addresses: `0x${string}`[];
+}, {
+    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, {
-        ethValue: string;
-        type: "ethValue";
-        operator: ">" | ">=" | "<" | "<=" | "==";
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
     }, {
-        ethValue: string;
-        type: "ethValue";
-        operator: ">" | ">=" | "<" | "<=" | "==";
+        inputs: readonly import("abitype").AbiParameter[];
+        type: "error";
+        name: string;
     }>, z.ZodObject<{
-        /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
-        type: z.ZodLiteral<"evmAddress">;
-        /**
-         * Array of EVM addresses to compare against.
+        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<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 /** The type of criterion, must be "evmTypedDataField" for typed data field-based rules. */<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 /**
+         * Array of EVM addresses allowed or disallowed as verifying contracts.
          * Each address must be a 0x-prefixed 40-character hexadecimal string.
          * Limited to a maximum of 300 addresses per criterion.
-         */
-        addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
-        /**
-         * The operator to use for evaluating transaction addresses.
-         * "in" checks if an address is in the provided list.
-         * "not in" checks if an address is not in the provided list.
-         */
-        operator: z.ZodEnum<["in", "not in"]>;
+         */<"payable">, z.ZodLiteral<"nonpayable">]>;
     }, "strip", z.ZodTypeAny, {
-        type: "evmAddress";
-        operator: "in" | "not in";
-        addresses: `0x${string}`[];
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
     }, {
-        type: "evmAddress";
-        operator: "in" | "not in";
-        addresses: string[];
+        type: "fallback";
+        stateMutability: "nonpayable" | "payable";
+        inputs?: [] | undefined;
     }>, z.ZodObject<{
-        /** The type of criterion, must be "evmData" for EVM transaction rules. */
-        type: z.ZodLiteral<"evmData">;
+        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 ABI of the smart contract being called. This can be a partial structure with only specific functions.
+         * The name of a smart contract function being called.
          */
-        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;
+        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, {
-            inputs: readonly import("abitype").AbiParameter[];
-            type: "error";
+            value: string;
             name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
         }, {
-            inputs: readonly import("abitype").AbiParameter[];
-            type: "error";
+            value: string;
             name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
         }>, 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">>;
+            /**
+             * 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";
+        } | {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }, {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            value: string;
+            name: 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";
+        } | {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }[];
+}, {
+    type: "evmData";
+    abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+    conditions: {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "netUSDChange" for USD denominated asset transfer rules. */
+    type: z.ZodLiteral<"netUSDChange">;
+    /**
+     * The amount of USD, in cents, that the total USD value of a transaction's asset transfer and exposure should be compared to.
+     */
+    changeCents: z.ZodNumber;
+    /**
+     * The operator to use for the comparison. The total value of a transaction's asset transfer and exposure in USD will be on the left-hand side of the operator, and the `changeCents` field will be on the right-hand side.
+     */
+    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+}, "strip", z.ZodTypeAny, {
+    type: "netUSDChange";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+    changeCents: number;
+}, {
+    type: "netUSDChange";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+    changeCents: number;
+}>]>, "many">;
+/**
+ * Type representing a set of criteria for the signEndUserEvmTransaction operation.
+ */
+export type SignEndUserEvmTransactionCriteria = z.infer<typeof SignEndUserEvmTransactionCriteriaSchema>;
+/**
+ * Schema for criteria used in SendEndUserEvmTransaction operations
+ */
+export declare const SendEndUserEvmTransactionCriteriaSchema: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    /** The type of criterion, must be "ethValue" for Ethereum value-based rules. */
+    type: z.ZodLiteral<"ethValue">;
+    /**
+     * The ETH value amount in wei to compare against, as a string.
+     * Must contain only digits.
+     */
+    ethValue: z.ZodString;
+    /** The comparison operator to use for evaluating transaction values against the threshold. */
+    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+}, "strip", z.ZodTypeAny, {
+    ethValue: string;
+    type: "ethValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}, {
+    ethValue: string;
+    type: "ethValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}>, z.ZodObject<{
+    /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
+    type: z.ZodLiteral<"evmAddress">;
+    /**
+     * Array of EVM addresses to compare against.
+     * Each address must be a 0x-prefixed 40-character hexadecimal string.
+     * Limited to a maximum of 300 addresses per criterion.
+     */
+    addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+    /**
+     * The operator to use for evaluating transaction addresses.
+     * "in" checks if an address is in the provided list.
+     * "not in" checks if an address is not in the provided list.
+     */
+    operator: z.ZodEnum<["in", "not in"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "evmAddress";
+    operator: "in" | "not in";
+    addresses: `0x${string}`[];
+}, {
+    type: "evmAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
+    type: z.ZodLiteral<"evmNetwork">;
+    /**
+     * Array of EVM network identifiers to compare against.
+     * Either "base-sepolia", "base", "arbitrum", "optimism", "zora", "polygon", "bnb", "avalanche", "ethereum", "ethereum-sepolia"
+     */
+    networks: z.ZodArray<z.ZodEnum<["base-sepolia", "base", "arbitrum", "optimism", "zora", "polygon", "bnb", "avalanche", "ethereum", "ethereum-sepolia"]>, "many">;
+    /**
+     * The operator to use for evaluating transaction network.
+     * "in" checks if a network is in the provided list.
+     * "not in" checks if a network is not in the provided list.
+     */
+    operator: z.ZodEnum<["in", "not in"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "evmNetwork";
+    operator: "in" | "not in";
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
+}, {
+    type: "evmNetwork";
+    operator: "in" | "not in";
+    networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
+}>, 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<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 /** The type of criterion, must be "evmTypedDataField" for typed data field-based rules. */<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 /**
+         * Array of EVM addresses allowed or disallowed as verifying contracts.
+         * Each address must be a 0x-prefixed 40-character hexadecimal string.
+         * Limited to a maximum of 300 addresses per criterion.
+         */<"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, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            value: string;
+            name: 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";
+        } | {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }, {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            value: string;
+            name: 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";
+        } | {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }[];
+}, {
+    type: "evmData";
+    abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+    conditions: {
+        function: string;
+        params?: ({
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        } | {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        })[] | undefined;
+    }[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "netUSDChange" for USD denominated asset transfer rules. */
+    type: z.ZodLiteral<"netUSDChange">;
+    /**
+     * The amount of USD, in cents, that the total USD value of a transaction's asset transfer and exposure should be compared to.
+     */
+    changeCents: z.ZodNumber;
+    /**
+     * The operator to use for the comparison. The total value of a transaction's asset transfer and exposure in USD will be on the left-hand side of the operator, and the `changeCents` field will be on the right-hand side.
+     */
+    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+}, "strip", z.ZodTypeAny, {
+    type: "netUSDChange";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+    changeCents: number;
+}, {
+    type: "netUSDChange";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+    changeCents: number;
+}>]>, "many">;
+/**
+ * Type representing a set of criteria for the sendEndUserEvmTransaction operation.
+ */
+export type SendEndUserEvmTransactionCriteria = z.infer<typeof SendEndUserEvmTransactionCriteriaSchema>;
+/**
+ * Schema for criteria used in SignEndUserEvmMessage operations
+ */
+export declare const SignEndUserEvmMessageCriteriaSchema: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    /** The type of criterion, must be "evmMessage" for EVM message-based rules. */
+    type: z.ZodLiteral<"evmMessage">;
+    /**
+     * A regular expression the message is matched against.
+     * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+     */
+    match: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    match: string;
+    type: "evmMessage";
+}, {
+    match: string;
+    type: "evmMessage";
+}>]>, "many">;
+/**
+ * Type representing a set of criteria for the signEndUserEvmMessage operation.
+ */
+export type SignEndUserEvmMessageCriteria = z.infer<typeof SignEndUserEvmMessageCriteriaSchema>;
+/**
+ * Schema for criteria used in SignEndUserEvmTypedData operations
+ */
+export declare const SignEndUserEvmTypedDataCriteriaSchema: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    /** The type of criterion, must be "evmTypedDataField" for typed data field-based rules. */
+    type: z.ZodLiteral<"evmTypedDataField">;
+    /**
+     * The EIP-712 type definitions for the typed data.
+     * Must include at minimum the primary type being signed.
+     */
+    types: z.ZodObject<{
+        /**
+         * EIP-712 compliant map of model names to model definitions.
+         */
+        types: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            name: string;
+        }, {
+            type: string;
+            name: string;
+        }>, "many">>;
+        /**
+         * The name of the root EIP-712 type. This value must be included in the `types` object.
+         */
+        primaryType: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        types: Record<string, {
+            type: string;
+            name: string;
+        }[]>;
+        primaryType: string;
+    }, {
+        types: Record<string, {
+            type: string;
+            name: string;
+        }[]>;
+        primaryType: string;
+    }>;
+    /**
+     * Array of conditions to apply against typed data fields.
+     * Each condition specifies how to validate a specific field within the typed data.
+     */
+    conditions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        /**
+         * Array of EVM addresses to compare against.
+         * Each address must be a 0x-prefixed 40-character hexadecimal string.
+         * Limited to a maximum of 300 addresses per condition.
+         */
+        addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+        /**
+         * The operator to use for evaluating addresses.
+         * "in" checks if an address is in the provided list.
+         * "not in" checks if an address is not in the provided list.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+        /**
+         * The path to the field to compare against this criterion.
+         * To reference deeply nested fields, use dot notation (e.g., "order.buyer").
+         */
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
+    }, {
+        path: string;
+        operator: "in" | "not in";
+        addresses: string[];
+    }>, z.ZodObject<{
+        /**
+         * The numerical value to compare against, as a string.
+         * Must contain only digits.
+         */
+        value: z.ZodString;
+        /**
+         * The comparison operator to use.
+         */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+        /**
+         * The path to the field to compare against this criterion.
+         * To reference deeply nested fields, use dot notation (e.g., "order.price").
+         */
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        path: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }, {
+        value: string;
+        path: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }>, z.ZodObject<{
+        /**
+         * A regular expression the string field is matched against.
+         * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+         */
+        match: z.ZodString;
+        /**
+         * The path to the field to compare against this criterion.
+         * To reference deeply nested fields, use dot notation (e.g., "metadata.description").
+         */
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        match: string;
+        path: string;
+    }, {
+        match: string;
+        path: string;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "evmTypedDataField";
+    types: {
+        types: Record<string, {
+            type: string;
+            name: string;
+        }[]>;
+        primaryType: string;
+    };
+    conditions: ({
+        path: string;
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
+    } | {
+        value: string;
+        path: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        match: string;
+        path: string;
+    })[];
+}, {
+    type: "evmTypedDataField";
+    types: {
+        types: Record<string, {
+            type: string;
+            name: string;
+        }[]>;
+        primaryType: string;
+    };
+    conditions: ({
+        path: string;
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        value: string;
+        path: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        match: string;
+        path: string;
+    })[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "evmTypedDataVerifyingContract" for verifying contract-based rules. */
+    type: z.ZodLiteral<"evmTypedDataVerifyingContract">;
+    /**
+     * Array of EVM addresses allowed or disallowed as verifying contracts.
+     * Each address must be a 0x-prefixed 40-character hexadecimal string.
+     * Limited to a maximum of 300 addresses per criterion.
+     */
+    addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+    /**
+     * The operator to use for evaluating verifying contract addresses.
+     * "in" checks if the verifying contract is in the provided list.
+     * "not in" checks if the verifying contract is not in the provided list.
+     */
+    operator: z.ZodEnum<["in", "not in"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "evmTypedDataVerifyingContract";
+    operator: "in" | "not in";
+    addresses: `0x${string}`[];
+}, {
+    type: "evmTypedDataVerifyingContract";
+    operator: "in" | "not in";
+    addresses: string[];
+}>]>, "many">;
+/**
+ * Type representing a set of criteria for the signEndUserEvmTypedData operation.
+ */
+export type SignEndUserEvmTypedDataCriteria = z.infer<typeof SignEndUserEvmTypedDataCriteriaSchema>;
+/**
+ * Enum for Evm Operation types
+ */
+export declare const EvmOperationEnum: z.ZodEnum<["signEvmTransaction", "sendEvmTransaction", "signEvmMessage", "signEvmTypedData", "signEvmHash", "prepareUserOperation", "sendUserOperation"]>;
+/**
+ * Type representing the operations that can be governed by a policy.
+ * Defines what EVM operations the policy applies to.
+ */
+export type EvmOperation = z.infer<typeof EvmOperationEnum>;
+/**
+ * Enum for Action types
+ */
+export declare const ActionEnum: z.ZodEnum<["reject", "accept"]>;
+/**
+ * Type representing the possible policy actions.
+ * Determines whether matching the rule will cause a request to be accepted or rejected.
+ */
+export type Action = z.infer<typeof ActionEnum>;
+/**
+ * Type representing a 'signEvmTransaction' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the transaction, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signEvmTransaction".
+     */
+    operation: z.ZodLiteral<"signEvmTransaction">;
+    /**
+     * The set of criteria that must be matched for this rule to apply.
+     * Must be compatible with the specified operation type.
+     */
+    criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        /** The type of criterion, must be "ethValue" for Ethereum value-based rules. */
+        type: z.ZodLiteral<"ethValue">;
+        /**
+         * The ETH value amount in wei to compare against, as a string.
+         * Must contain only digits.
+         */
+        ethValue: z.ZodString;
+        /** The comparison operator to use for evaluating transaction values against the threshold. */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    }, "strip", z.ZodTypeAny, {
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }, {
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
+        type: z.ZodLiteral<"evmAddress">;
+        /**
+         * Array of EVM addresses to compare against.
+         * Each address must be a 0x-prefixed 40-character hexadecimal string.
+         * Limited to a maximum of 300 addresses per criterion.
+         */
+        addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+        /**
+         * The operator to use for evaluating transaction addresses.
+         * "in" checks if an address is in the provided list.
+         * "not in" checks if an address is not in the provided list.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmAddress";
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
+    }, {
+        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<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 /** The type of criterion, must be "evmTypedDataField" for typed data field-based rules. */<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 /**
+             * Array of EVM addresses allowed or disallowed as verifying contracts.
+             * Each address must be a 0x-prefixed 40-character hexadecimal string.
+             * Limited to a maximum of 300 addresses per criterion.
+             */<"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, {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }, {
+                value: string;
+                name: 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";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: 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";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    }, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "netUSDChange" for USD denominated asset transfer rules. */
+        type: z.ZodLiteral<"netUSDChange">;
+        /**
+         * The amount of USD, in cents, that the total USD value of a transaction's asset transfer and exposure should be compared to.
+         */
+        changeCents: z.ZodNumber;
+        /**
+         * The operator to use for the comparison. The total value of a transaction's asset transfer and exposure in USD will be on the left-hand side of the operator, and the `changeCents` field will be on the right-hand side.
+         */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
+    }, {
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signEvmTransaction";
+    criteria: ({
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "evmAddress";
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
+    } | {
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
+    } | {
+        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";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    })[];
+}, {
+    action: "reject" | "accept";
+    operation: "signEvmTransaction";
+    criteria: ({
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "evmAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    })[];
+}>;
+export type SignEvmTransactionRule = z.infer<typeof SignEvmTransactionRuleSchema>;
+/**
+ * Type representing a 'signEvmHash' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SignEvmHashRuleSchema: z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the signing, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signEvmHash".
+     */
+    operation: z.ZodLiteral<"signEvmHash">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signEvmHash";
+}, {
+    action: "reject" | "accept";
+    operation: "signEvmHash";
+}>;
+export type SignEvmHashRule = z.infer<typeof SignEvmHashRuleSchema>;
+/**
+ * Type representing a 'signEvmMessage' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SignEvmMessageRuleSchema: z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the signing, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signEvmMessage".
+     */
+    operation: z.ZodLiteral<"signEvmMessage">;
+    /**
+     * The set of criteria that must be matched for this rule to apply.
+     * Must be compatible with the specified operation type.
+     */
+    criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        /** The type of criterion, must be "evmMessage" for EVM message-based rules. */
+        type: z.ZodLiteral<"evmMessage">;
+        /**
+         * A regular expression the message is matched against.
+         * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+         */
+        match: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        match: string;
+        type: "evmMessage";
+    }, {
+        match: string;
+        type: "evmMessage";
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signEvmMessage";
+    criteria: {
+        match: string;
+        type: "evmMessage";
+    }[];
+}, {
+    action: "reject" | "accept";
+    operation: "signEvmMessage";
+    criteria: {
+        match: string;
+        type: "evmMessage";
+    }[];
+}>;
+export type SignEvmMessageRule = z.infer<typeof SignEvmMessageRuleSchema>;
+/**
+ * Type representing a 'signEvmTypedData' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SignEvmTypedDataRuleSchema: z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the signing, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signEvmTypedData".
+     */
+    operation: z.ZodLiteral<"signEvmTypedData">;
+    /**
+     * The set of criteria that must be matched for this rule to apply.
+     * Must be compatible with the specified operation type.
+     */
+    criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        /** The type of criterion, must be "evmTypedDataField" for typed data field-based rules. */
+        type: z.ZodLiteral<"evmTypedDataField">;
+        /**
+         * The EIP-712 type definitions for the typed data.
+         * Must include at minimum the primary type being signed.
+         */
+        types: z.ZodObject<{
+            /**
+             * EIP-712 compliant map of model names to model definitions.
+             */
+            types: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                name: string;
+            }, {
+                type: string;
+                name: string;
+            }>, "many">>;
+            /**
+             * The name of the root EIP-712 type. This value must be included in the `types` object.
+             */
+            primaryType: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        }, {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        }>;
+        /**
+         * Array of conditions to apply against typed data fields.
+         * Each condition specifies how to validate a specific field within the typed data.
+         */
+        conditions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            /**
+             * Array of EVM addresses to compare against.
+             * Each address must be a 0x-prefixed 40-character hexadecimal string.
+             * Limited to a maximum of 300 addresses per condition.
+             */
+            addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+            /**
+             * The operator to use for evaluating addresses.
+             * "in" checks if an address is in the provided list.
+             * "not in" checks if an address is not in the provided list.
+             */
+            operator: z.ZodEnum<["in", "not in"]>;
+            /**
+             * The path to the field to compare against this criterion.
+             * To reference deeply nested fields, use dot notation (e.g., "order.buyer").
+             */
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            operator: "in" | "not in";
+            addresses: `0x${string}`[];
+        }, {
+            path: string;
+            operator: "in" | "not in";
+            addresses: string[];
+        }>, z.ZodObject<{
+            /**
+             * The numerical value to compare against, as a string.
+             * Must contain only digits.
+             */
+            value: z.ZodString;
+            /**
+             * The comparison operator to use.
+             */
+            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+            /**
+             * The path to the field to compare against this criterion.
+             * To reference deeply nested fields, use dot notation (e.g., "order.price").
+             */
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }>, z.ZodObject<{
+            /**
+             * A regular expression the string field is matched against.
+             * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+             */
+            match: z.ZodString;
+            /**
+             * The path to the field to compare against this criterion.
+             * To reference deeply nested fields, use dot notation (e.g., "metadata.description").
+             */
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            match: string;
+            path: string;
+        }, {
+            match: string;
+            path: string;
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmTypedDataField";
+        types: {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        };
+        conditions: ({
+            path: string;
+            operator: "in" | "not in";
+            addresses: `0x${string}`[];
+        } | {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            match: string;
+            path: string;
+        })[];
+    }, {
+        type: "evmTypedDataField";
+        types: {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        };
+        conditions: ({
+            path: string;
+            operator: "in" | "not in";
+            addresses: string[];
+        } | {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            match: string;
+            path: string;
+        })[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmTypedDataVerifyingContract" for verifying contract-based rules. */
+        type: z.ZodLiteral<"evmTypedDataVerifyingContract">;
+        /**
+         * Array of EVM addresses allowed or disallowed as verifying contracts.
+         * Each address must be a 0x-prefixed 40-character hexadecimal string.
+         * Limited to a maximum of 300 addresses per criterion.
+         */
+        addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+        /**
+         * The operator to use for evaluating verifying contract addresses.
+         * "in" checks if the verifying contract is in the provided list.
+         * "not in" checks if the verifying contract is not in the provided list.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmTypedDataVerifyingContract";
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
+    }, {
+        type: "evmTypedDataVerifyingContract";
+        operator: "in" | "not in";
+        addresses: string[];
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signEvmTypedData";
+    criteria: ({
+        type: "evmTypedDataField";
+        types: {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        };
+        conditions: ({
+            path: string;
+            operator: "in" | "not in";
+            addresses: `0x${string}`[];
+        } | {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            match: string;
+            path: string;
+        })[];
+    } | {
+        type: "evmTypedDataVerifyingContract";
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
+    })[];
+}, {
+    action: "reject" | "accept";
+    operation: "signEvmTypedData";
+    criteria: ({
+        type: "evmTypedDataField";
+        types: {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        };
+        conditions: ({
+            path: string;
+            operator: "in" | "not in";
+            addresses: string[];
+        } | {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            match: string;
+            path: string;
+        })[];
+    } | {
+        type: "evmTypedDataVerifyingContract";
+        operator: "in" | "not in";
+        addresses: string[];
+    })[];
+}>;
+export type SignEvmTypedDataRule = z.infer<typeof SignEvmTypedDataRuleSchema>;
+/**
+ * Type representing a 'sendEvmTransaction' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the transaction, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "sendEvmTransaction".
+     */
+    operation: z.ZodLiteral<"sendEvmTransaction">;
+    /**
+     * The set of criteria that must be matched for this rule to apply.
+     * Must be compatible with the specified operation type.
+     */
+    criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        /** The type of criterion, must be "ethValue" for Ethereum value-based rules. */
+        type: z.ZodLiteral<"ethValue">;
+        /**
+         * The ETH value amount in wei to compare against, as a string.
+         * Must contain only digits.
+         */
+        ethValue: z.ZodString;
+        /** The comparison operator to use for evaluating transaction values against the threshold. */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    }, "strip", z.ZodTypeAny, {
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }, {
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
+        type: z.ZodLiteral<"evmAddress">;
+        /**
+         * Array of EVM addresses to compare against.
+         * Each address must be a 0x-prefixed 40-character hexadecimal string.
+         * Limited to a maximum of 300 addresses per criterion.
+         */
+        addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+        /**
+         * The operator to use for evaluating transaction addresses.
+         * "in" checks if an address is in the provided list.
+         * "not in" checks if an address is not in the provided list.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmAddress";
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
+    }, {
+        type: "evmAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
+        type: z.ZodLiteral<"evmNetwork">;
+        /**
+         * Array of EVM network identifiers to compare against.
+         * Either "base", "base-sepolia", "ethereum", "ethereum-sepolia", "avalanche", "polygon", "optimism", "arbitrum"
+         */
+        networks: z.ZodArray<z.ZodEnum<["base", "base-sepolia", "ethereum", "ethereum-sepolia", "avalanche", "polygon", "optimism", "arbitrum"]>, "many">;
+        /**
+         * The operator to use for evaluating transaction network.
+         * "in" checks if a network is in the provided list.
+         * "not in" checks if a network is not in the provided list.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "avalanche")[];
+    }, {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "avalanche")[];
+    }>, 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[];
@@ -2882,7 +4571,7 @@ export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
-    operation: "signEvmTransaction";
+    operation: "sendEvmTransaction";
     criteria: ({
         ethValue: string;
         type: "ethValue";
@@ -2891,6 +4580,10 @@ export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: `0x${string}`[];
+    } | {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "avalanche")[];
     } | {
         type: "netUSDChange";
         operator: ">" | ">=" | "<" | "<=" | "==";
@@ -2943,7 +4636,7 @@ export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
     })[];
 }, {
     action: "reject" | "accept";
-    operation: "signEvmTransaction";
+    operation: "sendEvmTransaction";
     criteria: ({
         ethValue: string;
         type: "ethValue";
@@ -2952,6 +4645,10 @@ export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
+    } | {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "avalanche")[];
     } | {
         type: "netUSDChange";
         operator: ">" | ">=" | "<" | "<=" | "==";
@@ -2973,349 +4670,494 @@ export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
         }[];
     })[];
 }>;
-export type SignEvmTransactionRule = z.infer<typeof SignEvmTransactionRuleSchema>;
-/**
- * Type representing a 'signEvmHash' policy rule that can accept or reject specific operations
- * based on a set of criteria.
- */
-export declare const SignEvmHashRuleSchema: z.ZodObject<{
-    /**
-     * Determines whether matching the rule will cause a request to be rejected or accepted.
-     * "accept" will allow the signing, "reject" will block it.
-     */
-    action: z.ZodEnum<["reject", "accept"]>;
-    /**
-     * The operation to which this rule applies.
-     * Must be "signEvmHash".
-     */
-    operation: z.ZodLiteral<"signEvmHash">;
-}, "strip", z.ZodTypeAny, {
-    action: "reject" | "accept";
-    operation: "signEvmHash";
-}, {
-    action: "reject" | "accept";
-    operation: "signEvmHash";
-}>;
-export type SignEvmHashRule = z.infer<typeof SignEvmHashRuleSchema>;
+export type SendEvmTransactionRule = z.infer<typeof SendEvmTransactionRuleSchema>;
 /**
- * Type representing a 'signEvmMessage' policy rule that can accept or reject specific operations
+ * Type representing a 'prepareUserOperation' policy rule that can accept or reject specific operations
  * based on a set of criteria.
  */
-export declare const SignEvmMessageRuleSchema: z.ZodObject<{
+export declare const PrepareUserOperationRuleSchema: z.ZodObject<{
     /**
      * Determines whether matching the rule will cause a request to be rejected or accepted.
-     * "accept" will allow the signing, "reject" will block it.
+     * "accept" will allow the operation, "reject" will block it.
      */
     action: z.ZodEnum<["reject", "accept"]>;
     /**
      * The operation to which this rule applies.
-     * Must be "signEvmMessage".
+     * Must be "prepareUserOperation".
      */
-    operation: z.ZodLiteral<"signEvmMessage">;
+    operation: z.ZodLiteral<"prepareUserOperation">;
     /**
      * The set of criteria that must be matched for this rule to apply.
      * Must be compatible with the specified operation type.
      */
     criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-        /** The type of criterion, must be "evmMessage" for EVM message-based rules. */
-        type: z.ZodLiteral<"evmMessage">;
+        /** The type of criterion, must be "ethValue" for Ethereum value-based rules. */
+        type: z.ZodLiteral<"ethValue">;
         /**
-         * A regular expression the message is matched against.
-         * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+         * The ETH value amount in wei to compare against, as a string.
+         * Must contain only digits.
          */
-        match: z.ZodString;
+        ethValue: z.ZodString;
+        /** The comparison operator to use for evaluating transaction values against the threshold. */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
     }, "strip", z.ZodTypeAny, {
-        match: string;
-        type: "evmMessage";
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
     }, {
-        match: string;
-        type: "evmMessage";
-    }>]>, "many">;
-}, "strip", z.ZodTypeAny, {
-    action: "reject" | "accept";
-    operation: "signEvmMessage";
-    criteria: {
-        match: string;
-        type: "evmMessage";
-    }[];
-}, {
-    action: "reject" | "accept";
-    operation: "signEvmMessage";
-    criteria: {
-        match: string;
-        type: "evmMessage";
-    }[];
-}>;
-export type SignEvmMessageRule = z.infer<typeof SignEvmMessageRuleSchema>;
-/**
- * Type representing a 'signEvmTypedData' policy rule that can accept or reject specific operations
- * based on a set of criteria.
- */
-export declare const SignEvmTypedDataRuleSchema: z.ZodObject<{
-    /**
-     * Determines whether matching the rule will cause a request to be rejected or accepted.
-     * "accept" will allow the signing, "reject" will block it.
-     */
-    action: z.ZodEnum<["reject", "accept"]>;
-    /**
-     * The operation to which this rule applies.
-     * Must be "signEvmTypedData".
-     */
-    operation: z.ZodLiteral<"signEvmTypedData">;
-    /**
-     * The set of criteria that must be matched for this rule to apply.
-     * Must be compatible with the specified operation type.
-     */
-    criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-        /** The type of criterion, must be "evmTypedDataField" for typed data field-based rules. */
-        type: z.ZodLiteral<"evmTypedDataField">;
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
+        type: z.ZodLiteral<"evmAddress">;
+        /**
+         * Array of EVM addresses to compare against.
+         * Each address must be a 0x-prefixed 40-character hexadecimal string.
+         * Limited to a maximum of 300 addresses per criterion.
+         */
+        addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+        /**
+         * The operator to use for evaluating transaction addresses.
+         * "in" checks if an address is in the provided list.
+         * "not in" checks if an address is not in the provided list.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmAddress";
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
+    }, {
+        type: "evmAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
+        type: z.ZodLiteral<"evmNetwork">;
         /**
-         * The EIP-712 type definitions for the typed data.
-         * Must include at minimum the primary type being signed.
+         * Array of EVM network identifiers to compare against.
+         * Either "base-sepolia", "base", "arbitrum", "optimism", "zora", "polygon", "bnb", "avalanche", "ethereum", "ethereum-sepolia"
          */
-        types: z.ZodObject<{
-            /**
-             * EIP-712 compliant map of model names to model definitions.
-             */
-            types: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                type: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                type: string;
-                name: string;
-            }, {
-                type: string;
-                name: string;
-            }>, "many">>;
-            /**
-             * The name of the root EIP-712 type. This value must be included in the `types` object.
-             */
-            primaryType: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            types: Record<string, {
-                type: string;
-                name: string;
-            }[]>;
-            primaryType: string;
-        }, {
-            types: Record<string, {
-                type: string;
-                name: string;
-            }[]>;
-            primaryType: string;
-        }>;
+        networks: z.ZodArray<z.ZodEnum<["base-sepolia", "base", "arbitrum", "optimism", "zora", "polygon", "bnb", "avalanche", "ethereum", "ethereum-sepolia"]>, "many">;
         /**
-         * Array of conditions to apply against typed data fields.
-         * Each condition specifies how to validate a specific field within the typed data.
+         * The operator to use for evaluating transaction network.
+         * "in" checks if a network is in the provided list.
+         * "not in" checks if a network is not in the provided list.
          */
-        conditions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
-            /**
-             * Array of EVM addresses to compare against.
-             * Each address must be a 0x-prefixed 40-character hexadecimal string.
-             * Limited to a maximum of 300 addresses per condition.
-             */
-            addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
-            /**
-             * The operator to use for evaluating addresses.
-             * "in" checks if an address is in the provided list.
-             * "not in" checks if an address is not in the provided list.
-             */
-            operator: z.ZodEnum<["in", "not in"]>;
-            /**
-             * The path to the field to compare against this criterion.
-             * To reference deeply nested fields, use dot notation (e.g., "order.buyer").
-             */
-            path: z.ZodString;
+        operator: z.ZodEnum<["in", "not in"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
+    }, {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
+    }>, 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, {
-            path: string;
-            operator: "in" | "not in";
-            addresses: `0x${string}`[];
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
         }, {
-            path: string;
-            operator: "in" | "not in";
-            addresses: string[];
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
         }>, z.ZodObject<{
-            /**
-             * The numerical value to compare against, as a string.
-             * Must contain only digits.
-             */
-            value: z.ZodString;
-            /**
-             * The comparison operator to use.
-             */
-            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
-            /**
-             * The path to the field to compare against this criterion.
-             * To reference deeply nested fields, use dot notation (e.g., "order.price").
-             */
-            path: z.ZodString;
+            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, {
-            value: string;
-            path: string;
-            operator: ">" | ">=" | "<" | "<=" | "==";
+            inputs: readonly import("abitype").AbiEventParameter[];
+            type: "event";
+            name: string;
+            anonymous?: boolean | undefined;
         }, {
-            value: string;
-            path: string;
-            operator: ">" | ">=" | "<" | "<=" | "==";
+            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<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 /** The type of criterion, must be "evmTypedDataField" for typed data field-based rules. */<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 /**
+             * Array of EVM addresses allowed or disallowed as verifying contracts.
+             * Each address must be a 0x-prefixed 40-character hexadecimal string.
+             * Limited to a maximum of 300 addresses per criterion.
+             */<"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<{
             /**
-             * A regular expression the string field is matched against.
-             * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+             * The name of a smart contract function being called.
              */
-            match: z.ZodString;
+            function: z.ZodString;
             /**
-             * The path to the field to compare against this criterion.
-             * To reference deeply nested fields, use dot notation (e.g., "metadata.description").
+             * An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
              */
-            path: z.ZodString;
+            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, {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }, {
+                value: string;
+                name: 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, {
-            match: string;
-            path: string;
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
         }, {
-            match: string;
-            path: string;
-        }>]>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        type: "evmTypedDataField";
-        types: {
-            types: Record<string, {
-                type: string;
+            function: string;
+            params?: ({
+                values: string[];
                 name: string;
-            }[]>;
-            primaryType: string;
-        };
-        conditions: ({
-            path: string;
-            operator: "in" | "not in";
-            addresses: `0x${string}`[];
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly ({
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
         } | {
-            value: string;
-            path: string;
-            operator: ">" | ">=" | "<" | "<=" | "==";
+            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";
         } | {
-            match: string;
-            path: string;
-        })[];
-    }, {
-        type: "evmTypedDataField";
-        types: {
-            types: Record<string, {
-                type: string;
-                name: string;
-            }[]>;
-            primaryType: string;
-        };
-        conditions: ({
-            path: string;
-            operator: "in" | "not in";
-            addresses: string[];
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "constructor";
+            stateMutability: "nonpayable" | "payable";
         } | {
-            value: string;
-            path: string;
-            operator: ">" | ">=" | "<" | "<=" | "==";
+            type: "fallback";
+            stateMutability: "nonpayable" | "payable";
+            inputs?: [] | undefined;
         } | {
-            match: string;
-            path: string;
-        })[];
+            type: "receive";
+            stateMutability: "payable";
+        })))[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    }, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     }>, z.ZodObject<{
-        /** The type of criterion, must be "evmTypedDataVerifyingContract" for verifying contract-based rules. */
-        type: z.ZodLiteral<"evmTypedDataVerifyingContract">;
+        /** The type of criterion, must be "netUSDChange" for USD denominated asset transfer rules. */
+        type: z.ZodLiteral<"netUSDChange">;
         /**
-         * Array of EVM addresses allowed or disallowed as verifying contracts.
-         * Each address must be a 0x-prefixed 40-character hexadecimal string.
-         * Limited to a maximum of 300 addresses per criterion.
+         * The amount of USD, in cents, that the total USD value of a transaction's asset transfer and exposure should be compared to.
          */
-        addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+        changeCents: z.ZodNumber;
         /**
-         * The operator to use for evaluating verifying contract addresses.
-         * "in" checks if the verifying contract is in the provided list.
-         * "not in" checks if the verifying contract is not in the provided list.
+         * The operator to use for the comparison. The total value of a transaction's asset transfer and exposure in USD will be on the left-hand side of the operator, and the `changeCents` field will be on the right-hand side.
          */
-        operator: z.ZodEnum<["in", "not in"]>;
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
     }, "strip", z.ZodTypeAny, {
-        type: "evmTypedDataVerifyingContract";
-        operator: "in" | "not in";
-        addresses: `0x${string}`[];
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
     }, {
-        type: "evmTypedDataVerifyingContract";
-        operator: "in" | "not in";
-        addresses: string[];
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
-    operation: "signEvmTypedData";
+    operation: "prepareUserOperation";
     criteria: ({
-        type: "evmTypedDataField";
-        types: {
-            types: Record<string, {
-                type: string;
-                name: string;
-            }[]>;
-            primaryType: string;
-        };
-        conditions: ({
-            path: string;
-            operator: "in" | "not in";
-            addresses: `0x${string}`[];
-        } | {
-            value: string;
-            path: string;
-            operator: ">" | ">=" | "<" | "<=" | "==";
-        } | {
-            match: string;
-            path: string;
-        })[];
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
     } | {
-        type: "evmTypedDataVerifyingContract";
+        type: "evmAddress";
         operator: "in" | "not in";
         addresses: `0x${string}`[];
-    })[];
-}, {
-    action: "reject" | "accept";
-    operation: "signEvmTypedData";
-    criteria: ({
-        type: "evmTypedDataField";
-        types: {
-            types: Record<string, {
-                type: string;
-                name: string;
-            }[]>;
-            primaryType: string;
-        };
-        conditions: ({
-            path: string;
-            operator: "in" | "not in";
-            addresses: string[];
+    } | {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
+    } | {
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly ({
+            inputs: readonly import("abitype").AbiParameter[];
+            type: "error";
+            name: string;
         } | {
-            value: string;
-            path: string;
-            operator: ">" | ">=" | "<" | "<=" | "==";
+            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";
         } | {
-            match: string;
-            path: string;
-        })[];
+            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";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    })[];
+}, {
+    action: "reject" | "accept";
+    operation: "prepareUserOperation";
+    criteria: ({
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
     } | {
-        type: "evmTypedDataVerifyingContract";
+        type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
+    } | {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
+    } | {
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
     })[];
 }>;
-export type SignEvmTypedDataRule = z.infer<typeof SignEvmTypedDataRuleSchema>;
+export type PrepareUserOperationRule = z.infer<typeof PrepareUserOperationRuleSchema>;
 /**
- * Type representing a 'sendEvmTransaction' policy rule that can accept or reject specific operations
+ * Type representing a 'sendUserOperation' policy rule that can accept or reject specific operations
  * based on a set of criteria.
  */
-export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
+export declare const SendUserOperationRuleSchema: z.ZodObject<{
     /**
      * Determines whether matching the rule will cause a request to be rejected or accepted.
-     * "accept" will allow the transaction, "reject" will block it.
+     * "accept" will allow the operation, "reject" will block it.
      */
     action: z.ZodEnum<["reject", "accept"]>;
     /**
      * The operation to which this rule applies.
-     * Must be "sendEvmTransaction".
+     * Must be "sendUserOperation".
      */
-    operation: z.ZodLiteral<"sendEvmTransaction">;
+    operation: z.ZodLiteral<"sendUserOperation">;
     /**
      * The set of criteria that must be matched for this rule to apply.
      * Must be compatible with the specified operation type.
@@ -3361,28 +5203,6 @@ export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
-    }>, z.ZodObject<{
-        /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
-        type: z.ZodLiteral<"evmNetwork">;
-        /**
-         * Array of EVM network identifiers to compare against.
-         * Either "base", "base-sepolia", "ethereum", "ethereum-sepolia", "avalanche", "polygon", "optimism", "arbitrum"
-         */
-        networks: z.ZodArray<z.ZodEnum<["base", "base-sepolia", "ethereum", "ethereum-sepolia", "avalanche", "polygon", "optimism", "arbitrum"]>, "many">;
-        /**
-         * The operator to use for evaluating transaction network.
-         * "in" checks if a network is in the provided list.
-         * "not in" checks if a network is not in the provided list.
-         */
-        operator: z.ZodEnum<["in", "not in"]>;
-    }, "strip", z.ZodTypeAny, {
-        type: "evmNetwork";
-        operator: "in" | "not in";
-        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
-    }, {
-        type: "evmNetwork";
-        operator: "in" | "not in";
-        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
     }>, z.ZodObject<{
         /** The type of criterion, must be "evmData" for EVM transaction rules. */
         type: z.ZodLiteral<"evmData">;
@@ -3673,7 +5493,7 @@ export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
-    operation: "sendEvmTransaction";
+    operation: "sendUserOperation";
     criteria: ({
         ethValue: string;
         type: "ethValue";
@@ -3682,10 +5502,6 @@ export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: `0x${string}`[];
-    } | {
-        type: "evmNetwork";
-        operator: "in" | "not in";
-        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
     } | {
         type: "netUSDChange";
         operator: ">" | ">=" | "<" | "<=" | "==";
@@ -3738,7 +5554,7 @@ export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
     })[];
 }, {
     action: "reject" | "accept";
-    operation: "sendEvmTransaction";
+    operation: "sendUserOperation";
     criteria: ({
         ethValue: string;
         type: "ethValue";
@@ -3747,10 +5563,6 @@ export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
-    } | {
-        type: "evmNetwork";
-        operator: "in" | "not in";
-        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
     } | {
         type: "netUSDChange";
         operator: ">" | ">=" | "<" | "<=" | "==";
@@ -3772,22 +5584,22 @@ export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
         }[];
     })[];
 }>;
-export type SendEvmTransactionRule = z.infer<typeof SendEvmTransactionRuleSchema>;
+export type SendUserOperationRule = z.infer<typeof SendUserOperationRuleSchema>;
 /**
- * Type representing a 'prepareUserOperation' policy rule that can accept or reject specific operations
+ * Type representing a 'signEndUserEvmTransaction' policy rule that can accept or reject specific operations
  * based on a set of criteria.
  */
-export declare const PrepareUserOperationRuleSchema: z.ZodObject<{
+export declare const SignEndUserEvmTransactionRuleSchema: z.ZodObject<{
     /**
      * Determines whether matching the rule will cause a request to be rejected or accepted.
-     * "accept" will allow the operation, "reject" will block it.
+     * "accept" will allow the transaction, "reject" will block it.
      */
     action: z.ZodEnum<["reject", "accept"]>;
     /**
      * The operation to which this rule applies.
-     * Must be "prepareUserOperation".
+     * Must be "signEndUserEvmTransaction".
      */
-    operation: z.ZodLiteral<"prepareUserOperation">;
+    operation: z.ZodLiteral<"signEndUserEvmTransaction">;
     /**
      * The set of criteria that must be matched for this rule to apply.
      * Must be compatible with the specified operation type.
@@ -3833,28 +5645,6 @@ export declare const PrepareUserOperationRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
-    }>, z.ZodObject<{
-        /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
-        type: z.ZodLiteral<"evmNetwork">;
-        /**
-         * Array of EVM network identifiers to compare against.
-         * Either "base-sepolia", "base", "arbitrum", "optimism", "zora", "polygon", "bnb", "avalanche", "ethereum", "ethereum-sepolia"
-         */
-        networks: z.ZodArray<z.ZodEnum<["base-sepolia", "base", "arbitrum", "optimism", "zora", "polygon", "bnb", "avalanche", "ethereum", "ethereum-sepolia"]>, "many">;
-        /**
-         * The operator to use for evaluating transaction network.
-         * "in" checks if a network is in the provided list.
-         * "not in" checks if a network is not in the provided list.
-         */
-        operator: z.ZodEnum<["in", "not in"]>;
-    }, "strip", z.ZodTypeAny, {
-        type: "evmNetwork";
-        operator: "in" | "not in";
-        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "zora" | "polygon" | "bnb" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
-    }, {
-        type: "evmNetwork";
-        operator: "in" | "not in";
-        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "zora" | "polygon" | "bnb" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
     }>, z.ZodObject<{
         /** The type of criterion, must be "evmData" for EVM transaction rules. */
         type: z.ZodLiteral<"evmData">;
@@ -4145,7 +5935,7 @@ export declare const PrepareUserOperationRuleSchema: z.ZodObject<{
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
-    operation: "prepareUserOperation";
+    operation: "signEndUserEvmTransaction";
     criteria: ({
         ethValue: string;
         type: "ethValue";
@@ -4154,10 +5944,6 @@ export declare const PrepareUserOperationRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: `0x${string}`[];
-    } | {
-        type: "evmNetwork";
-        operator: "in" | "not in";
-        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "zora" | "polygon" | "bnb" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
     } | {
         type: "netUSDChange";
         operator: ">" | ">=" | "<" | "<=" | "==";
@@ -4210,7 +5996,7 @@ export declare const PrepareUserOperationRuleSchema: z.ZodObject<{
     })[];
 }, {
     action: "reject" | "accept";
-    operation: "prepareUserOperation";
+    operation: "signEndUserEvmTransaction";
     criteria: ({
         ethValue: string;
         type: "ethValue";
@@ -4219,10 +6005,6 @@ export declare const PrepareUserOperationRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
-    } | {
-        type: "evmNetwork";
-        operator: "in" | "not in";
-        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "zora" | "polygon" | "bnb" | "avalanche" | "ethereum" | "ethereum-sepolia")[];
     } | {
         type: "netUSDChange";
         operator: ">" | ">=" | "<" | "<=" | "==";
@@ -4244,22 +6026,22 @@ export declare const PrepareUserOperationRuleSchema: z.ZodObject<{
         }[];
     })[];
 }>;
-export type PrepareUserOperationRule = z.infer<typeof PrepareUserOperationRuleSchema>;
+export type SignEndUserEvmTransactionRule = z.infer<typeof SignEndUserEvmTransactionRuleSchema>;
 /**
- * Type representing a 'sendUserOperation' policy rule that can accept or reject specific operations
+ * Type representing a 'sendEndUserEvmTransaction' policy rule that can accept or reject specific operations
  * based on a set of criteria.
  */
-export declare const SendUserOperationRuleSchema: z.ZodObject<{
+export declare const SendEndUserEvmTransactionRuleSchema: z.ZodObject<{
     /**
      * Determines whether matching the rule will cause a request to be rejected or accepted.
-     * "accept" will allow the operation, "reject" will block it.
+     * "accept" will allow the transaction, "reject" will block it.
      */
     action: z.ZodEnum<["reject", "accept"]>;
     /**
      * The operation to which this rule applies.
-     * Must be "sendUserOperation".
+     * Must be "sendEndUserEvmTransaction".
      */
-    operation: z.ZodLiteral<"sendUserOperation">;
+    operation: z.ZodLiteral<"sendEndUserEvmTransaction">;
     /**
      * The set of criteria that must be matched for this rule to apply.
      * Must be compatible with the specified operation type.
@@ -4305,6 +6087,28 @@ export declare const SendUserOperationRuleSchema: z.ZodObject<{
         type: "evmAddress";
         operator: "in" | "not in";
         addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
+        type: z.ZodLiteral<"evmNetwork">;
+        /**
+         * Array of EVM network identifiers to compare against.
+         * Either "base-sepolia", "base", "arbitrum", "optimism", "zora", "polygon", "bnb", "avalanche", "ethereum", "ethereum-sepolia"
+         */
+        networks: z.ZodArray<z.ZodEnum<["base-sepolia", "base", "arbitrum", "optimism", "zora", "polygon", "bnb", "avalanche", "ethereum", "ethereum-sepolia"]>, "many">;
+        /**
+         * The operator to use for evaluating transaction network.
+         * "in" checks if a network is in the provided list.
+         * "not in" checks if a network is not in the provided list.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
+    }, {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
     }>, z.ZodObject<{
         /** The type of criterion, must be "evmData" for EVM transaction rules. */
         type: z.ZodLiteral<"evmData">;
@@ -4485,12 +6289,202 @@ export declare const SendUserOperationRuleSchema: z.ZodObject<{
                 values: string[];
                 name: string;
                 operator: "in" | "not in";
-            }, {
-                values: string[];
+            }, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }>]>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }, {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: 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";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    }, {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
+            function: string;
+            params?: ({
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            } | {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "netUSDChange" for USD denominated asset transfer rules. */
+        type: z.ZodLiteral<"netUSDChange">;
+        /**
+         * The amount of USD, in cents, that the total USD value of a transaction's asset transfer and exposure should be compared to.
+         */
+        changeCents: z.ZodNumber;
+        /**
+         * The operator to use for the comparison. The total value of a transaction's asset transfer and exposure in USD will be on the left-hand side of the operator, and the `changeCents` field will be on the right-hand side.
+         */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
+    }, {
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "sendEndUserEvmTransaction";
+    criteria: ({
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "evmAddress";
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
+    } | {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
+    } | {
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
+    } | {
+        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";
+            } | {
+                value: string;
                 name: string;
-                operator: "in" | "not in";
-            }>]>, "many">>;
-        }, "strip", z.ZodTypeAny, {
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            })[] | undefined;
+        }[];
+    })[];
+}, {
+    action: "reject" | "accept";
+    operation: "sendEndUserEvmTransaction";
+    criteria: ({
+        ethValue: string;
+        type: "ethValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "evmAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        type: "evmNetwork";
+        operator: "in" | "not in";
+        networks: ("base-sepolia" | "base" | "arbitrum" | "optimism" | "polygon" | "ethereum" | "ethereum-sepolia" | "zora" | "bnb" | "avalanche")[];
+    } | {
+        type: "netUSDChange";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+        changeCents: number;
+    } | {
+        type: "evmData";
+        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
+        conditions: {
             function: string;
             params?: ({
                 values: string[];
@@ -4501,190 +6495,312 @@ export declare const SendUserOperationRuleSchema: z.ZodObject<{
                 name: string;
                 operator: ">" | ">=" | "<" | "<=" | "==";
             })[] | undefined;
+        }[];
+    })[];
+}>;
+export type SendEndUserEvmTransactionRule = z.infer<typeof SendEndUserEvmTransactionRuleSchema>;
+/**
+ * Type representing a 'signEndUserEvmMessage' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SignEndUserEvmMessageRuleSchema: z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the signing, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signEndUserEvmMessage".
+     */
+    operation: z.ZodLiteral<"signEndUserEvmMessage">;
+    /**
+     * The set of criteria that must be matched for this rule to apply.
+     * Must be compatible with the specified operation type.
+     */
+    criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        /** The type of criterion, must be "evmMessage" for EVM message-based rules. */
+        type: z.ZodLiteral<"evmMessage">;
+        /**
+         * A regular expression the message is matched against.
+         * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+         */
+        match: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        match: string;
+        type: "evmMessage";
+    }, {
+        match: string;
+        type: "evmMessage";
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signEndUserEvmMessage";
+    criteria: {
+        match: string;
+        type: "evmMessage";
+    }[];
+}, {
+    action: "reject" | "accept";
+    operation: "signEndUserEvmMessage";
+    criteria: {
+        match: string;
+        type: "evmMessage";
+    }[];
+}>;
+export type SignEndUserEvmMessageRule = z.infer<typeof SignEndUserEvmMessageRuleSchema>;
+/**
+ * Type representing a 'signEndUserEvmTypedData' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SignEndUserEvmTypedDataRuleSchema: z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the signing, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signEndUserEvmTypedData".
+     */
+    operation: z.ZodLiteral<"signEndUserEvmTypedData">;
+    /**
+     * The set of criteria that must be matched for this rule to apply.
+     * Must be compatible with the specified operation type.
+     */
+    criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        /** The type of criterion, must be "evmTypedDataField" for typed data field-based rules. */
+        type: z.ZodLiteral<"evmTypedDataField">;
+        /**
+         * The EIP-712 type definitions for the typed data.
+         * Must include at minimum the primary type being signed.
+         */
+        types: z.ZodObject<{
+            /**
+             * EIP-712 compliant map of model names to model definitions.
+             */
+            types: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                name: string;
+            }, {
+                type: string;
+                name: string;
+            }>, "many">>;
+            /**
+             * The name of the root EIP-712 type. This value must be included in the `types` object.
+             */
+            primaryType: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        }, {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        }>;
+        /**
+         * Array of conditions to apply against typed data fields.
+         * Each condition specifies how to validate a specific field within the typed data.
+         */
+        conditions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            /**
+             * Array of EVM addresses to compare against.
+             * Each address must be a 0x-prefixed 40-character hexadecimal string.
+             * Limited to a maximum of 300 addresses per condition.
+             */
+            addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+            /**
+             * The operator to use for evaluating addresses.
+             * "in" checks if an address is in the provided list.
+             * "not in" checks if an address is not in the provided list.
+             */
+            operator: z.ZodEnum<["in", "not in"]>;
+            /**
+             * The path to the field to compare against this criterion.
+             * To reference deeply nested fields, use dot notation (e.g., "order.buyer").
+             */
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            operator: "in" | "not in";
+            addresses: `0x${string}`[];
+        }, {
+            path: string;
+            operator: "in" | "not in";
+            addresses: string[];
+        }>, z.ZodObject<{
+            /**
+             * The numerical value to compare against, as a string.
+             * Must contain only digits.
+             */
+            value: z.ZodString;
+            /**
+             * The comparison operator to use.
+             */
+            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+            /**
+             * The path to the field to compare against this criterion.
+             * To reference deeply nested fields, use dot notation (e.g., "order.price").
+             */
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }>, z.ZodObject<{
+            /**
+             * A regular expression the string field is matched against.
+             * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+             */
+            match: z.ZodString;
+            /**
+             * The path to the field to compare against this criterion.
+             * To reference deeply nested fields, use dot notation (e.g., "metadata.description").
+             */
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            match: string;
+            path: string;
         }, {
-            function: string;
-            params?: ({
-                values: string[];
-                name: string;
-                operator: "in" | "not in";
-            } | {
-                value: string;
-                name: string;
-                operator: ">" | ">=" | "<" | "<=" | "==";
-            })[] | undefined;
-        }>, "many">;
+            match: string;
+            path: string;
+        }>]>, "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: "evmTypedDataField";
+        types: {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        };
+        conditions: ({
+            path: string;
+            operator: "in" | "not in";
+            addresses: `0x${string}`[];
         } | {
-            type: "fallback";
-            stateMutability: "nonpayable" | "payable";
-            inputs?: [] | undefined;
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
         } | {
-            type: "receive";
-            stateMutability: "payable";
-        })))[];
-        conditions: {
-            function: string;
-            params?: ({
-                values: string[];
-                name: string;
-                operator: "in" | "not in";
-            } | {
-                value: string;
-                name: string;
-                operator: ">" | ">=" | "<" | "<=" | "==";
-            })[] | undefined;
-        }[];
+            match: string;
+            path: string;
+        })[];
     }, {
-        type: "evmData";
-        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
-        conditions: {
-            function: string;
-            params?: ({
-                values: string[];
-                name: string;
-                operator: "in" | "not in";
-            } | {
-                value: string;
+        type: "evmTypedDataField";
+        types: {
+            types: Record<string, {
+                type: string;
                 name: string;
-                operator: ">" | ">=" | "<" | "<=" | "==";
-            })[] | undefined;
-        }[];
+            }[]>;
+            primaryType: string;
+        };
+        conditions: ({
+            path: string;
+            operator: "in" | "not in";
+            addresses: string[];
+        } | {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            match: string;
+            path: string;
+        })[];
     }>, z.ZodObject<{
-        /** The type of criterion, must be "netUSDChange" for USD denominated asset transfer rules. */
-        type: z.ZodLiteral<"netUSDChange">;
+        /** The type of criterion, must be "evmTypedDataVerifyingContract" for verifying contract-based rules. */
+        type: z.ZodLiteral<"evmTypedDataVerifyingContract">;
         /**
-         * The amount of USD, in cents, that the total USD value of a transaction's asset transfer and exposure should be compared to.
+         * Array of EVM addresses allowed or disallowed as verifying contracts.
+         * Each address must be a 0x-prefixed 40-character hexadecimal string.
+         * Limited to a maximum of 300 addresses per criterion.
          */
-        changeCents: z.ZodNumber;
+        addresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
         /**
-         * The operator to use for the comparison. The total value of a transaction's asset transfer and exposure in USD will be on the left-hand side of the operator, and the `changeCents` field will be on the right-hand side.
+         * The operator to use for evaluating verifying contract addresses.
+         * "in" checks if the verifying contract is in the provided list.
+         * "not in" checks if the verifying contract is not in the provided list.
          */
-        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+        operator: z.ZodEnum<["in", "not in"]>;
     }, "strip", z.ZodTypeAny, {
-        type: "netUSDChange";
-        operator: ">" | ">=" | "<" | "<=" | "==";
-        changeCents: number;
+        type: "evmTypedDataVerifyingContract";
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
     }, {
-        type: "netUSDChange";
-        operator: ">" | ">=" | "<" | "<=" | "==";
-        changeCents: number;
+        type: "evmTypedDataVerifyingContract";
+        operator: "in" | "not in";
+        addresses: string[];
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
-    operation: "sendUserOperation";
+    operation: "signEndUserEvmTypedData";
     criteria: ({
-        ethValue: string;
-        type: "ethValue";
-        operator: ">" | ">=" | "<" | "<=" | "==";
+        type: "evmTypedDataField";
+        types: {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        };
+        conditions: ({
+            path: string;
+            operator: "in" | "not in";
+            addresses: `0x${string}`[];
+        } | {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            match: string;
+            path: string;
+        })[];
     } | {
-        type: "evmAddress";
+        type: "evmTypedDataVerifyingContract";
         operator: "in" | "not in";
         addresses: `0x${string}`[];
-    } | {
-        type: "netUSDChange";
-        operator: ">" | ">=" | "<" | "<=" | "==";
-        changeCents: number;
-    } | {
-        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";
-            } | {
-                value: string;
-                name: string;
-                operator: ">" | ">=" | "<" | "<=" | "==";
-            })[] | undefined;
-        }[];
     })[];
 }, {
     action: "reject" | "accept";
-    operation: "sendUserOperation";
+    operation: "signEndUserEvmTypedData";
     criteria: ({
-        ethValue: string;
-        type: "ethValue";
-        operator: ">" | ">=" | "<" | "<=" | "==";
+        type: "evmTypedDataField";
+        types: {
+            types: Record<string, {
+                type: string;
+                name: string;
+            }[]>;
+            primaryType: string;
+        };
+        conditions: ({
+            path: string;
+            operator: "in" | "not in";
+            addresses: string[];
+        } | {
+            value: string;
+            path: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            match: string;
+            path: string;
+        })[];
     } | {
-        type: "evmAddress";
+        type: "evmTypedDataVerifyingContract";
         operator: "in" | "not in";
         addresses: string[];
-    } | {
-        type: "netUSDChange";
-        operator: ">" | ">=" | "<" | "<=" | "==";
-        changeCents: number;
-    } | {
-        type: "evmData";
-        abi: "erc20" | "erc721" | "erc1155" | readonly unknown[];
-        conditions: {
-            function: string;
-            params?: ({
-                values: string[];
-                name: string;
-                operator: "in" | "not in";
-            } | {
-                value: string;
-                name: string;
-                operator: ">" | ">=" | "<" | "<=" | "==";
-            })[] | undefined;
-        }[];
     })[];
 }>;
-export type SendUserOperationRule = z.infer<typeof SendUserOperationRuleSchema>;
+export type SignEndUserEvmTypedDataRule = z.infer<typeof SignEndUserEvmTypedDataRuleSchema>;
 //# sourceMappingURL=evmSchema.d.ts.map