@coinbase/cdp-sdk 1.22.0 → 1.23.0

package/_types/policies/schema.d.ts

@@ -140,6 +140,454 @@ export declare const EvmMessageCriterionSchema: z.ZodObject<{
     type: "evmMessage";
 }>;
 export type EvmMessageCriterion = z.infer<typeof EvmMessageCriterionSchema>;
+/**
+ * Schema for EVM typed address conditions
+ */
+export declare const EvmTypedAddressConditionSchema: 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 100 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[];
+}>;
+export type EvmTypedAddressCondition = z.infer<typeof EvmTypedAddressConditionSchema>;
+/**
+ * Schema for EVM typed numerical conditions
+ */
+export declare const EvmTypedNumericalConditionSchema: 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: ">" | ">=" | "<" | "<=" | "==";
+}>;
+export type EvmTypedNumericalCondition = z.infer<typeof EvmTypedNumericalConditionSchema>;
+/**
+ * Schema for EVM typed string conditions
+ */
+export declare const EvmTypedStringConditionSchema: 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;
+}>;
+export type EvmTypedStringCondition = z.infer<typeof EvmTypedStringConditionSchema>;
+/**
+ * Schema for SignEvmTypedData field criterion
+ */
+export declare const SignEvmTypedDataFieldCriterionSchema: 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 100 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;
+    })[];
+}>;
+export type SignEvmTypedDataFieldCriterion = z.infer<typeof SignEvmTypedDataFieldCriterionSchema>;
+/**
+ * Schema for SignEvmTypedData verifying contract criterion
+ */
+export declare const SignEvmTypedDataVerifyingContractCriterionSchema: 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 100 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[];
+}>;
+export type SignEvmTypedDataVerifyingContractCriterion = z.infer<typeof SignEvmTypedDataVerifyingContractCriterionSchema>;
+/**
+ * Schema for criteria used in SignEvmTypedData operations
+ */
+export declare const SignEvmTypedDataCriteriaSchema: 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 100 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 100 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 signEvmTypedData operation.
+ * Can contain up to 10 individual criterion objects for typed data field or verifying contract checks.
+ */
+export type SignEvmTypedDataCriteria = z.infer<typeof SignEvmTypedDataCriteriaSchema>;
 /**
  * A list of comparables to apply against encoded arguments in the transaction's `data` field.
  */
@@ -326,7 +774,7 @@ export declare const EvmDataCriterionSchema: z.ZodObject<{
         anonymous?: boolean | undefined;
     }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
         constant: z.ZodOptional<z.ZodBoolean>;
-        gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+        gas: z.ZodOptional<z.ZodNumber>;
         payable: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         payable?: boolean | undefined;
@@ -663,7 +1111,7 @@ export declare const SignEvmTransactionCriteriaSchema: z.ZodArray<z.ZodDiscrimin
         anonymous?: boolean | undefined;
     }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
         constant: z.ZodOptional<z.ZodBoolean>;
-        gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+        gas: z.ZodOptional<z.ZodNumber>;
         payable: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         payable?: boolean | undefined;
@@ -1022,7 +1470,7 @@ export declare const SendEvmTransactionCriteriaSchema: z.ZodArray<z.ZodDiscrimin
         anonymous?: boolean | undefined;
     }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
         constant: z.ZodOptional<z.ZodBoolean>;
-        gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+        gas: z.ZodOptional<z.ZodNumber>;
         payable: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         payable?: boolean | undefined;
@@ -1406,7 +1854,7 @@ export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
             anonymous?: boolean | undefined;
         }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
             constant: z.ZodOptional<z.ZodBoolean>;
-            gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+            gas: z.ZodOptional<z.ZodNumber>;
             payable: z.ZodOptional<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             payable?: boolean | undefined;
@@ -1771,30 +2219,284 @@ export declare const SignEvmMessageRuleSchema: z.ZodObject<{
          * 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;
+        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 100 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 100 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, {
-        match: string;
-        type: "evmMessage";
+        type: "evmTypedDataVerifyingContract";
+        operator: "in" | "not in";
+        addresses: `0x${string}`[];
     }, {
-        match: string;
-        type: "evmMessage";
+        type: "evmTypedDataVerifyingContract";
+        operator: "in" | "not in";
+        addresses: string[];
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
-    operation: "signEvmMessage";
-    criteria: {
-        match: string;
-        type: "evmMessage";
-    }[];
+    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: "signEvmMessage";
-    criteria: {
-        match: string;
-        type: "evmMessage";
-    }[];
+    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 SignEvmMessageRule = z.infer<typeof SignEvmMessageRuleSchema>;
+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.
@@ -1912,7 +2614,7 @@ export declare const SendEvmTransactionRuleSchema: z.ZodObject<{
             anonymous?: boolean | undefined;
         }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
             constant: z.ZodOptional<z.ZodBoolean>;
-            gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+            gas: z.ZodOptional<z.ZodNumber>;
             payable: z.ZodOptional<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             payable?: boolean | undefined;
@@ -2390,7 +3092,7 @@ export declare const RuleSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObje
             anonymous?: boolean | undefined;
         }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
             constant: z.ZodOptional<z.ZodBoolean>;
-            gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+            gas: z.ZodOptional<z.ZodNumber>;
             payable: z.ZodOptional<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             payable?: boolean | undefined;
@@ -2765,6 +3467,254 @@ export declare const RuleSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObje
         match: string;
         type: "evmMessage";
     }[];
+}>, 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 100 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 100 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[];
+    })[];
 }>, z.ZodObject<{
     /**
      * Determines whether matching the rule will cause a request to be rejected or accepted.
@@ -2878,7 +3828,7 @@ export declare const RuleSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObje
             anonymous?: boolean | undefined;
         }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
             constant: z.ZodOptional<z.ZodBoolean>;
-            gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+            gas: z.ZodOptional<z.ZodNumber>;
             payable: z.ZodOptional<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             payable?: boolean | undefined;
@@ -3378,7 +4328,7 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
                 anonymous?: boolean | undefined;
             }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
                 constant: z.ZodOptional<z.ZodBoolean>;
-                gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+                gas: z.ZodOptional<z.ZodNumber>;
                 payable: z.ZodOptional<z.ZodBoolean>;
             }, "strip", z.ZodTypeAny, {
                 payable?: boolean | undefined;
@@ -3728,31 +4678,279 @@ export declare const CreatePolicyBodySchema: 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).
+             * 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";
+        }[];
+    }>, 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 100 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 100 addresses per criterion.
              */
-            match: z.ZodString;
+            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, {
-            match: string;
-            type: "evmMessage";
+            type: "evmTypedDataVerifyingContract";
+            operator: "in" | "not in";
+            addresses: `0x${string}`[];
         }, {
-            match: string;
-            type: "evmMessage";
+            type: "evmTypedDataVerifyingContract";
+            operator: "in" | "not in";
+            addresses: string[];
         }>]>, "many">;
     }, "strip", z.ZodTypeAny, {
         action: "reject" | "accept";
-        operation: "signEvmMessage";
-        criteria: {
-            match: string;
-            type: "evmMessage";
-        }[];
+        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: "signEvmMessage";
-        criteria: {
-            match: string;
-            type: "evmMessage";
-        }[];
+        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[];
+        })[];
     }>, z.ZodObject<{
         /**
          * Determines whether matching the rule will cause a request to be rejected or accepted.
@@ -3866,7 +5064,7 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
                 anonymous?: boolean | undefined;
             }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
                 constant: z.ZodOptional<z.ZodBoolean>;
-                gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+                gas: z.ZodOptional<z.ZodNumber>;
                 payable: z.ZodOptional<z.ZodBoolean>;
             }, "strip", z.ZodTypeAny, {
                 payable?: boolean | undefined;
@@ -4312,6 +5510,35 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             match: string;
             type: "evmMessage";
         }[];
+    } | {
+        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: "sendEvmTransaction";
@@ -4422,6 +5649,35 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             match: string;
             type: "evmMessage";
         }[];
+    } | {
+        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[];
+        })[];
     } | {
         action: "reject" | "accept";
         operation: "sendEvmTransaction";
@@ -4570,7 +5826,7 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
                 anonymous?: boolean | undefined;
             }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
                 constant: z.ZodOptional<z.ZodBoolean>;
-                gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+                gas: z.ZodOptional<z.ZodNumber>;
                 payable: z.ZodOptional<z.ZodBoolean>;
             }, "strip", z.ZodTypeAny, {
                 payable?: boolean | undefined;
@@ -4945,6 +6201,254 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             match: string;
             type: "evmMessage";
         }[];
+    }>, 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 100 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 100 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[];
+        })[];
     }>, z.ZodObject<{
         /**
          * Determines whether matching the rule will cause a request to be rejected or accepted.
@@ -5058,7 +6562,7 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
                 anonymous?: boolean | undefined;
             }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
                 constant: z.ZodOptional<z.ZodBoolean>;
-                gas: z.ZodOptional /** The type of criterion, must be "solAddress" for Solana address-based rules. */<z.ZodNumber>;
+                gas: z.ZodOptional<z.ZodNumber>;
                 payable: z.ZodOptional<z.ZodBoolean>;
             }, "strip", z.ZodTypeAny, {
                 payable?: boolean | undefined;
@@ -5503,6 +7007,35 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             match: string;
             type: "evmMessage";
         }[];
+    } | {
+        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: "sendEvmTransaction";
@@ -5612,6 +7145,35 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             match: string;
             type: "evmMessage";
         }[];
+    } | {
+        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[];
+        })[];
     } | {
         action: "reject" | "accept";
         operation: "sendEvmTransaction";