@coinbase/cdp-sdk 1.44.1 → 1.46.0

package/_types/policies/solanaSchema.d.ts

@@ -1088,20 +1088,1406 @@ export declare const SendSolTransactionCriteriaSchema: z.ZodArray<z.ZodDiscrimin
  * Can contain up to 10 individual criterion objects for Solana addresses, SOL values, SPL addresses, SPL values, mint addresses, Solana data, program IDs, and network restrictions.
  */
 export type SendSolTransactionCriteria = z.infer<typeof SendSolTransactionCriteriaSchema>;
+/**
+ * Schema for criteria used in SignEndUserSolTransaction operations
+ */
+export declare const SignEndUserSolTransactionCriteriaSchema: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    /** The type of criterion, must be "solAddress" for Solana address-based rules. */
+    type: z.ZodLiteral<"solAddress">;
+    /**
+     * Array of Solana addresses to compare against.
+     * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+     */
+    addresses: z.ZodArray<z.ZodString, "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: "solAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}, {
+    type: "solAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "solValue" for SOL value-based rules. */
+    type: z.ZodLiteral<"solValue">;
+    /**
+     * The SOL value amount in lamports to compare against, as a string.
+     * Must contain only digits.
+     */
+    solValue: z.ZodString;
+    /** The comparison operator to use for evaluating transaction SOL values against the threshold. */
+    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+}, "strip", z.ZodTypeAny, {
+    solValue: string;
+    type: "solValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}, {
+    solValue: string;
+    type: "solValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}>, z.ZodObject<{
+    /** The type of criterion, must be "splAddress" for SPL address-based rules. */
+    type: z.ZodLiteral<"splAddress">;
+    /**
+     * Array of Solana addresses to compare against for SPL token transfer recipients.
+     * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+     */
+    addresses: z.ZodArray<z.ZodString, "many">;
+    /**
+     * The operator to use for evaluating SPL token transfer recipient 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: "splAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}, {
+    type: "splAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "splValue" for SPL token value-based rules. */
+    type: z.ZodLiteral<"splValue">;
+    /**
+     * The SPL token value amount to compare against, as a string.
+     * Must contain only digits.
+     */
+    splValue: z.ZodString;
+    /** The comparison operator to use for evaluating SPL token values against the threshold. */
+    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+}, "strip", z.ZodTypeAny, {
+    splValue: string;
+    type: "splValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}, {
+    splValue: string;
+    type: "splValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}>, z.ZodObject<{
+    /** The type of criterion, must be "mintAddress" for token mint address-based rules. */
+    type: z.ZodLiteral<"mintAddress">;
+    /**
+     * Array of Solana addresses to compare against for token mint addresses.
+     * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+     */
+    addresses: z.ZodArray<z.ZodString, "many">;
+    /**
+     * The operator to use for evaluating token mint 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: "mintAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}, {
+    type: "mintAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "solData" for Solana data-based rules. */
+    type: z.ZodLiteral<"solData">;
+    /**
+     * List of IDL specifications. Can contain known program names (strings) or custom IDL objects.
+     */
+    idls: z.ZodArray<z.ZodUnion<[z.ZodEnum<["SystemProgram", "TokenProgram", "AssociatedTokenProgram"]>, z.ZodObject<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">;
+    /**
+     * A list of conditions to apply against the transaction instruction.
+     * Only one condition must evaluate to true for this criterion to be met.
+     */
+    conditions: z.ZodArray<z.ZodObject<{
+        /** The instruction name */
+        instruction: z.ZodString;
+        /** Parameter conditions for the instruction */
+        params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            /** The parameter name */
+            name: z.ZodString;
+            /** The operator to use for the comparison */
+            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+            /** The value to compare against */
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }>, z.ZodObject<{
+            /** The parameter name */
+            name: z.ZodString;
+            /** The operator to use for the comparison */
+            operator: z.ZodEnum<["in", "not in"]>;
+            /** The values to compare against */
+            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, {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }, {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "solData";
+    conditions: {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }[];
+    idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">)[];
+}, {
+    type: "solData";
+    conditions: {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }[];
+    idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">)[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "programId" for program ID-based rules. */
+    type: z.ZodLiteral<"programId">;
+    /**
+     * Array of Solana program IDs to compare against.
+     * Each program ID must be a valid Base58-encoded Solana address (32-44 characters).
+     */
+    programIds: z.ZodArray<z.ZodString, "many">;
+    /**
+     * The operator to use for evaluating transaction program IDs.
+     * "in" checks if a program ID is in the provided list.
+     * "not in" checks if a program ID is not in the provided list.
+     */
+    operator: z.ZodEnum<["in", "not in"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "programId";
+    operator: "in" | "not in";
+    programIds: string[];
+}, {
+    type: "programId";
+    operator: "in" | "not in";
+    programIds: string[];
+}>]>, "many">;
+/**
+ * Type representing a set of criteria for the signEndUserSolTransaction operation.
+ */
+export type SignEndUserSolTransactionCriteria = z.infer<typeof SignEndUserSolTransactionCriteriaSchema>;
+/**
+ * Schema for criteria used in SendEndUserSolTransaction operations
+ */
+export declare const SendEndUserSolTransactionCriteriaSchema: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    /** The type of criterion, must be "solAddress" for Solana address-based rules. */
+    type: z.ZodLiteral<"solAddress">;
+    /**
+     * Array of Solana addresses to compare against.
+     * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+     */
+    addresses: z.ZodArray<z.ZodString, "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: "solAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}, {
+    type: "solAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "solValue" for SOL value-based rules. */
+    type: z.ZodLiteral<"solValue">;
+    /**
+     * The SOL value amount in lamports to compare against, as a string.
+     * Must contain only digits.
+     */
+    solValue: z.ZodString;
+    /** The comparison operator to use for evaluating transaction SOL values against the threshold. */
+    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+}, "strip", z.ZodTypeAny, {
+    solValue: string;
+    type: "solValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}, {
+    solValue: string;
+    type: "solValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}>, z.ZodObject<{
+    /** The type of criterion, must be "splAddress" for SPL address-based rules. */
+    type: z.ZodLiteral<"splAddress">;
+    /**
+     * Array of Solana addresses to compare against for SPL token transfer recipients.
+     * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+     */
+    addresses: z.ZodArray<z.ZodString, "many">;
+    /**
+     * The operator to use for evaluating SPL token transfer recipient 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: "splAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}, {
+    type: "splAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "splValue" for SPL token value-based rules. */
+    type: z.ZodLiteral<"splValue">;
+    /**
+     * The SPL token value amount to compare against, as a string.
+     * Must contain only digits.
+     */
+    splValue: z.ZodString;
+    /** The comparison operator to use for evaluating SPL token values against the threshold. */
+    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+}, "strip", z.ZodTypeAny, {
+    splValue: string;
+    type: "splValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}, {
+    splValue: string;
+    type: "splValue";
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}>, z.ZodObject<{
+    /** The type of criterion, must be "mintAddress" for token mint address-based rules. */
+    type: z.ZodLiteral<"mintAddress">;
+    /**
+     * Array of Solana addresses to compare against for token mint addresses.
+     * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+     */
+    addresses: z.ZodArray<z.ZodString, "many">;
+    /**
+     * The operator to use for evaluating token mint 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: "mintAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}, {
+    type: "mintAddress";
+    operator: "in" | "not in";
+    addresses: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "solData" for Solana data-based rules. */
+    type: z.ZodLiteral<"solData">;
+    /**
+     * List of IDL specifications. Can contain known program names (strings) or custom IDL objects.
+     */
+    idls: z.ZodArray<z.ZodUnion<[z.ZodEnum<["SystemProgram", "TokenProgram", "AssociatedTokenProgram"]>, z.ZodObject<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">;
+    /**
+     * A list of conditions to apply against the transaction instruction.
+     * Only one condition must evaluate to true for this criterion to be met.
+     */
+    conditions: z.ZodArray<z.ZodObject<{
+        /** The instruction name */
+        instruction: z.ZodString;
+        /** Parameter conditions for the instruction */
+        params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            /** The parameter name */
+            name: z.ZodString;
+            /** The operator to use for the comparison */
+            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+            /** The value to compare against */
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }>, z.ZodObject<{
+            /** The parameter name */
+            name: z.ZodString;
+            /** The operator to use for the comparison */
+            operator: z.ZodEnum<["in", "not in"]>;
+            /** The values to compare against */
+            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, {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }, {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "solData";
+    conditions: {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }[];
+    idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">)[];
+}, {
+    type: "solData";
+    conditions: {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }[];
+    idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">)[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "programId" for program ID-based rules. */
+    type: z.ZodLiteral<"programId">;
+    /**
+     * Array of Solana program IDs to compare against.
+     * Each program ID must be a valid Base58-encoded Solana address (32-44 characters).
+     */
+    programIds: z.ZodArray<z.ZodString, "many">;
+    /**
+     * The operator to use for evaluating transaction program IDs.
+     * "in" checks if a program ID is in the provided list.
+     * "not in" checks if a program ID is not in the provided list.
+     */
+    operator: z.ZodEnum<["in", "not in"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "programId";
+    operator: "in" | "not in";
+    programIds: string[];
+}, {
+    type: "programId";
+    operator: "in" | "not in";
+    programIds: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "solNetwork" for network-based rules. */
+    type: z.ZodLiteral<"solNetwork">;
+    /**
+     * Array of Solana networks to compare against.
+     */
+    networks: z.ZodArray<z.ZodEnum<["solana-devnet", "solana"]>, "many">;
+    /**
+     * The operator to use for evaluating transaction network.
+     * "in" checks if the network is in the provided list.
+     * "not in" checks if the network is not in the provided list.
+     */
+    operator: z.ZodEnum<["in", "not in"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "solNetwork";
+    operator: "in" | "not in";
+    networks: ("solana-devnet" | "solana")[];
+}, {
+    type: "solNetwork";
+    operator: "in" | "not in";
+    networks: ("solana-devnet" | "solana")[];
+}>]>, "many">;
+/**
+ * Type representing a set of criteria for the sendEndUserSolTransaction operation.
+ */
+export type SendEndUserSolTransactionCriteria = z.infer<typeof SendEndUserSolTransactionCriteriaSchema>;
+/**
+ * Schema for criteria used in SignEndUserSolMessage operations
+ */
+export declare const SignEndUserSolMessageCriteriaSchema: z.ZodArray<z.ZodObject<{
+    /** The type of criterion, must be "solMessage" for message-based rules. */
+    type: z.ZodLiteral<"solMessage">;
+    /**
+     * A regular expression pattern to match against the message.
+     */
+    match: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    match: string;
+    type: "solMessage";
+}, {
+    match: string;
+    type: "solMessage";
+}>, "many">;
+/**
+ * Type representing a set of criteria for the signEndUserSolMessage operation.
+ */
+export type SignEndUserSolMessageCriteria = z.infer<typeof SignEndUserSolMessageCriteriaSchema>;
 /**
  * Enum for Solana Operation types
  */
-export declare const SolOperationEnum: z.ZodEnum<["signSolTransaction", "sendSolTransaction", "signSolMessage"]>;
+export declare const SolOperationEnum: z.ZodEnum<["signSolTransaction", "sendSolTransaction", "signSolMessage"]>;
+/**
+ * Type representing the operations that can be governed by a policy.
+ * Defines what Solana operations the policy applies to.
+ */
+export type SolOperation = z.infer<typeof SolOperationEnum>;
+/**
+ * Type representing a 'signSolTransaction' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SignSolTransactionRuleSchema: 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 "signSolTransaction".
+     */
+    operation: z.ZodLiteral<"signSolTransaction">;
+    /**
+     * 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 "solAddress" for Solana address-based rules. */
+        type: z.ZodLiteral<"solAddress">;
+        /**
+         * Array of Solana addresses to compare against.
+         * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+         */
+        addresses: z.ZodArray<z.ZodString, "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: "solAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }, {
+        type: "solAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "solValue" for SOL value-based rules. */
+        type: z.ZodLiteral<"solValue">;
+        /**
+         * The SOL value amount in lamports to compare against, as a string.
+         * Must contain only digits.
+         */
+        solValue: z.ZodString;
+        /** The comparison operator to use for evaluating transaction SOL values against the threshold. */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    }, "strip", z.ZodTypeAny, {
+        solValue: string;
+        type: "solValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }, {
+        solValue: string;
+        type: "solValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "splAddress" for SPL address-based rules. */
+        type: z.ZodLiteral<"splAddress">;
+        /**
+         * Array of Solana addresses to compare against for SPL token transfer recipients.
+         * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+         */
+        addresses: z.ZodArray<z.ZodString, "many">;
+        /**
+         * The operator to use for evaluating SPL token transfer recipient 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: "splAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }, {
+        type: "splAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "splValue" for SPL token value-based rules. */
+        type: z.ZodLiteral<"splValue">;
+        /**
+         * The SPL token value amount to compare against, as a string.
+         * Must contain only digits.
+         */
+        splValue: z.ZodString;
+        /** The comparison operator to use for evaluating SPL token values against the threshold. */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    }, "strip", z.ZodTypeAny, {
+        splValue: string;
+        type: "splValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }, {
+        splValue: string;
+        type: "splValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "mintAddress" for token mint address-based rules. */
+        type: z.ZodLiteral<"mintAddress">;
+        /**
+         * Array of Solana addresses to compare against for token mint addresses.
+         * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+         */
+        addresses: z.ZodArray<z.ZodString, "many">;
+        /**
+         * The operator to use for evaluating token mint 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: "mintAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }, {
+        type: "mintAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "solData" for Solana data-based rules. */
+        type: z.ZodLiteral<"solData">;
+        /**
+         * List of IDL specifications. Can contain known program names (strings) or custom IDL objects.
+         */
+        idls: z.ZodArray<z.ZodUnion<[z.ZodEnum<["SystemProgram", "TokenProgram", "AssociatedTokenProgram"]>, z.ZodObject<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">>]>, "many">;
+        /**
+         * A list of conditions to apply against the transaction instruction.
+         * Only one condition must evaluate to true for this criterion to be met.
+         */
+        conditions: z.ZodArray<z.ZodObject<{
+            /** The instruction name */
+            instruction: z.ZodString;
+            /** Parameter conditions for the instruction */
+            params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                /** The parameter name */
+                name: z.ZodString;
+                /** The operator to use for the comparison */
+                operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                /** The value to compare against */
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }, {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }>, z.ZodObject<{
+                /** The parameter name */
+                name: z.ZodString;
+                /** The operator to use for the comparison */
+                operator: z.ZodEnum<["in", "not in"]>;
+                /** The values to compare against */
+                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, {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }, {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
+    }, {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "programId" for program ID-based rules. */
+        type: z.ZodLiteral<"programId">;
+        /**
+         * Array of Solana program IDs to compare against.
+         * Each program ID must be a valid Base58-encoded Solana address (32-44 characters).
+         */
+        programIds: z.ZodArray<z.ZodString, "many">;
+        /**
+         * The operator to use for evaluating transaction program IDs.
+         * "in" checks if a program ID is in the provided list.
+         * "not in" checks if a program ID is not in the provided list.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "programId";
+        operator: "in" | "not in";
+        programIds: string[];
+    }, {
+        type: "programId";
+        operator: "in" | "not in";
+        programIds: string[];
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signSolTransaction";
+    criteria: ({
+        type: "solAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        solValue: string;
+        type: "solValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "splAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        splValue: string;
+        type: "splValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "mintAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
+    } | {
+        type: "programId";
+        operator: "in" | "not in";
+        programIds: string[];
+    })[];
+}, {
+    action: "reject" | "accept";
+    operation: "signSolTransaction";
+    criteria: ({
+        type: "solAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        solValue: string;
+        type: "solValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "splAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        splValue: string;
+        type: "splValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "mintAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
+    } | {
+        type: "programId";
+        operator: "in" | "not in";
+        programIds: string[];
+    })[];
+}>;
+export type SignSolTransactionRule = z.infer<typeof SignSolTransactionRuleSchema>;
+/**
+ * Type representing a 'sendSolTransaction' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SendSolTransactionRuleSchema: 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 "sendSolTransaction".
+     */
+    operation: z.ZodLiteral<"sendSolTransaction">;
+    /**
+     * 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 "solAddress" for Solana address-based rules. */
+        type: z.ZodLiteral<"solAddress">;
+        /**
+         * Array of Solana addresses to compare against.
+         * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+         */
+        addresses: z.ZodArray<z.ZodString, "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: "solAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }, {
+        type: "solAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "solValue" for SOL value-based rules. */
+        type: z.ZodLiteral<"solValue">;
+        /**
+         * The SOL value amount in lamports to compare against, as a string.
+         * Must contain only digits.
+         */
+        solValue: z.ZodString;
+        /** The comparison operator to use for evaluating transaction SOL values against the threshold. */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    }, "strip", z.ZodTypeAny, {
+        solValue: string;
+        type: "solValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }, {
+        solValue: string;
+        type: "solValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "splAddress" for SPL address-based rules. */
+        type: z.ZodLiteral<"splAddress">;
+        /**
+         * Array of Solana addresses to compare against for SPL token transfer recipients.
+         * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+         */
+        addresses: z.ZodArray<z.ZodString, "many">;
+        /**
+         * The operator to use for evaluating SPL token transfer recipient 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: "splAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }, {
+        type: "splAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "splValue" for SPL token value-based rules. */
+        type: z.ZodLiteral<"splValue">;
+        /**
+         * The SPL token value amount to compare against, as a string.
+         * Must contain only digits.
+         */
+        splValue: z.ZodString;
+        /** The comparison operator to use for evaluating SPL token values against the threshold. */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    }, "strip", z.ZodTypeAny, {
+        splValue: string;
+        type: "splValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }, {
+        splValue: string;
+        type: "splValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "mintAddress" for token mint address-based rules. */
+        type: z.ZodLiteral<"mintAddress">;
+        /**
+         * Array of Solana addresses to compare against for token mint addresses.
+         * Each address must be a valid Base58-encoded Solana address (32-44 characters).
+         */
+        addresses: z.ZodArray<z.ZodString, "many">;
+        /**
+         * The operator to use for evaluating token mint 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: "mintAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }, {
+        type: "mintAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "solData" for Solana data-based rules. */
+        type: z.ZodLiteral<"solData">;
+        /**
+         * List of IDL specifications. Can contain known program names (strings) or custom IDL objects.
+         */
+        idls: z.ZodArray<z.ZodUnion<[z.ZodEnum<["SystemProgram", "TokenProgram", "AssociatedTokenProgram"]>, z.ZodObject<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">>]>, "many">;
+        /**
+         * A list of conditions to apply against the transaction instruction.
+         * Only one condition must evaluate to true for this criterion to be met.
+         */
+        conditions: z.ZodArray<z.ZodObject<{
+            /** The instruction name */
+            instruction: z.ZodString;
+            /** Parameter conditions for the instruction */
+            params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                /** The parameter name */
+                name: z.ZodString;
+                /** The operator to use for the comparison */
+                operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                /** The value to compare against */
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }, {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }>, z.ZodObject<{
+                /** The parameter name */
+                name: z.ZodString;
+                /** The operator to use for the comparison */
+                operator: z.ZodEnum<["in", "not in"]>;
+                /** The values to compare against */
+                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, {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }, {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
+    }, {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "programId" for program ID-based rules. */
+        type: z.ZodLiteral<"programId">;
+        /**
+         * Array of Solana program IDs to compare against.
+         * Each program ID must be a valid Base58-encoded Solana address (32-44 characters).
+         */
+        programIds: z.ZodArray<z.ZodString, "many">;
+        /**
+         * The operator to use for evaluating transaction program IDs.
+         * "in" checks if a program ID is in the provided list.
+         * "not in" checks if a program ID is not in the provided list.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "programId";
+        operator: "in" | "not in";
+        programIds: string[];
+    }, {
+        type: "programId";
+        operator: "in" | "not in";
+        programIds: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "solNetwork" for network-based rules. */
+        type: z.ZodLiteral<"solNetwork">;
+        /**
+         * Array of Solana networks to compare against.
+         */
+        networks: z.ZodArray<z.ZodEnum<["solana-devnet", "solana"]>, "many">;
+        /**
+         * The operator to use for evaluating transaction network.
+         * "in" checks if the network is in the provided list.
+         * "not in" checks if the network is not in the provided list.
+         */
+        operator: z.ZodEnum<["in", "not in"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "solNetwork";
+        operator: "in" | "not in";
+        networks: ("solana-devnet" | "solana")[];
+    }, {
+        type: "solNetwork";
+        operator: "in" | "not in";
+        networks: ("solana-devnet" | "solana")[];
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "sendSolTransaction";
+    criteria: ({
+        type: "solAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        solValue: string;
+        type: "solValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "splAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        splValue: string;
+        type: "splValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "mintAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
+    } | {
+        type: "programId";
+        operator: "in" | "not in";
+        programIds: string[];
+    } | {
+        type: "solNetwork";
+        operator: "in" | "not in";
+        networks: ("solana-devnet" | "solana")[];
+    })[];
+}, {
+    action: "reject" | "accept";
+    operation: "sendSolTransaction";
+    criteria: ({
+        type: "solAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        solValue: string;
+        type: "solValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "splAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        splValue: string;
+        type: "splValue";
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        type: "mintAddress";
+        operator: "in" | "not in";
+        addresses: string[];
+    } | {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
+    } | {
+        type: "programId";
+        operator: "in" | "not in";
+        programIds: string[];
+    } | {
+        type: "solNetwork";
+        operator: "in" | "not in";
+        networks: ("solana-devnet" | "solana")[];
+    })[];
+}>;
+export type SendSolTransactionRule = z.infer<typeof SendSolTransactionRuleSchema>;
+/**
+ * Schema for criteria used in SignSolMessage operations
+ */
+export declare const SignSolMessageCriteriaSchema: z.ZodArray<z.ZodObject<{
+    /** The type of criterion, must be "solMessage" for message-based rules. */
+    type: z.ZodLiteral<"solMessage">;
+    /**
+     * A regular expression pattern to match against the message.
+     */
+    match: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    match: string;
+    type: "solMessage";
+}, {
+    match: string;
+    type: "solMessage";
+}>, "many">;
 /**
- * Type representing the operations that can be governed by a policy.
- * Defines what Solana operations the policy applies to.
+ * Type representing a set of criteria for the signSolMessage operation.
+ * Can contain up to 10 individual criterion objects for Solana message matching.
  */
-export type SolOperation = z.infer<typeof SolOperationEnum>;
+export type SignSolMessageCriteria = z.infer<typeof SignSolMessageCriteriaSchema>;
 /**
- * Type representing a 'signSolTransaction' policy rule that can accept or reject specific operations
+ * Type representing a 'signSolMessage' policy rule that can accept or reject specific operations
  * based on a set of criteria.
  */
-export declare const SignSolTransactionRuleSchema: z.ZodObject<{
+export declare const SignSolMessageRuleSchema: z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the message signing, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signSolMessage".
+     */
+    operation: z.ZodLiteral<"signSolMessage">;
+    /**
+     * 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.ZodObject<{
+        /** The type of criterion, must be "solMessage" for message-based rules. */
+        type: z.ZodLiteral<"solMessage">;
+        /**
+         * A regular expression pattern to match against the message.
+         */
+        match: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        match: string;
+        type: "solMessage";
+    }, {
+        match: string;
+        type: "solMessage";
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signSolMessage";
+    criteria: {
+        match: string;
+        type: "solMessage";
+    }[];
+}, {
+    action: "reject" | "accept";
+    operation: "signSolMessage";
+    criteria: {
+        match: string;
+        type: "solMessage";
+    }[];
+}>;
+export type SignSolMessageRule = z.infer<typeof SignSolMessageRuleSchema>;
+/**
+ * Type representing a 'signEndUserSolTransaction' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SignEndUserSolTransactionRuleSchema: 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.
@@ -1109,9 +2495,9 @@ export declare const SignSolTransactionRuleSchema: z.ZodObject<{
     action: z.ZodEnum<["reject", "accept"]>;
     /**
      * The operation to which this rule applies.
-     * Must be "signSolTransaction".
+     * Must be "signEndUserSolTransaction".
      */
-    operation: z.ZodLiteral<"signSolTransaction">;
+    operation: z.ZodLiteral<"signEndUserSolTransaction">;
     /**
      * The set of criteria that must be matched for this rule to apply.
      * Must be compatible with the specified operation type.
@@ -1367,7 +2753,7 @@ export declare const SignSolTransactionRuleSchema: z.ZodObject<{
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
-    operation: "signSolTransaction";
+    operation: "signEndUserSolTransaction";
     criteria: ({
         type: "solAddress";
         operator: "in" | "not in";
@@ -1415,7 +2801,7 @@ export declare const SignSolTransactionRuleSchema: z.ZodObject<{
     })[];
 }, {
     action: "reject" | "accept";
-    operation: "signSolTransaction";
+    operation: "signEndUserSolTransaction";
     criteria: ({
         type: "solAddress";
         operator: "in" | "not in";
@@ -1462,12 +2848,12 @@ export declare const SignSolTransactionRuleSchema: z.ZodObject<{
         programIds: string[];
     })[];
 }>;
-export type SignSolTransactionRule = z.infer<typeof SignSolTransactionRuleSchema>;
+export type SignEndUserSolTransactionRule = z.infer<typeof SignEndUserSolTransactionRuleSchema>;
 /**
- * Type representing a 'sendSolTransaction' policy rule that can accept or reject specific operations
+ * Type representing a 'sendEndUserSolTransaction' policy rule that can accept or reject specific operations
  * based on a set of criteria.
  */
-export declare const SendSolTransactionRuleSchema: z.ZodObject<{
+export declare const SendEndUserSolTransactionRuleSchema: 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.
@@ -1475,9 +2861,9 @@ export declare const SendSolTransactionRuleSchema: z.ZodObject<{
     action: z.ZodEnum<["reject", "accept"]>;
     /**
      * The operation to which this rule applies.
-     * Must be "sendSolTransaction".
+     * Must be "sendEndUserSolTransaction".
      */
-    operation: z.ZodLiteral<"sendSolTransaction">;
+    operation: z.ZodLiteral<"sendEndUserSolTransaction">;
     /**
      * The set of criteria that must be matched for this rule to apply.
      * Must be compatible with the specified operation type.
@@ -1754,7 +3140,7 @@ export declare const SendSolTransactionRuleSchema: z.ZodObject<{
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
-    operation: "sendSolTransaction";
+    operation: "sendEndUserSolTransaction";
     criteria: ({
         type: "solAddress";
         operator: "in" | "not in";
@@ -1806,7 +3192,7 @@ export declare const SendSolTransactionRuleSchema: z.ZodObject<{
     })[];
 }, {
     action: "reject" | "accept";
-    operation: "sendSolTransaction";
+    operation: "sendEndUserSolTransaction";
     criteria: ({
         type: "solAddress";
         operator: "in" | "not in";
@@ -1857,34 +3243,12 @@ export declare const SendSolTransactionRuleSchema: z.ZodObject<{
         networks: ("solana-devnet" | "solana")[];
     })[];
 }>;
-export type SendSolTransactionRule = z.infer<typeof SendSolTransactionRuleSchema>;
-/**
- * Schema for criteria used in SignSolMessage operations
- */
-export declare const SignSolMessageCriteriaSchema: z.ZodArray<z.ZodObject<{
-    /** The type of criterion, must be "solMessage" for message-based rules. */
-    type: z.ZodLiteral<"solMessage">;
-    /**
-     * A regular expression pattern to match against the message.
-     */
-    match: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    match: string;
-    type: "solMessage";
-}, {
-    match: string;
-    type: "solMessage";
-}>, "many">;
-/**
- * Type representing a set of criteria for the signSolMessage operation.
- * Can contain up to 10 individual criterion objects for Solana message matching.
- */
-export type SignSolMessageCriteria = z.infer<typeof SignSolMessageCriteriaSchema>;
+export type SendEndUserSolTransactionRule = z.infer<typeof SendEndUserSolTransactionRuleSchema>;
 /**
- * Type representing a 'signSolMessage' policy rule that can accept or reject specific operations
+ * Type representing a 'signEndUserSolMessage' policy rule that can accept or reject specific operations
  * based on a set of criteria.
  */
-export declare const SignSolMessageRuleSchema: z.ZodObject<{
+export declare const SignEndUserSolMessageRuleSchema: z.ZodObject<{
     /**
      * Determines whether matching the rule will cause a request to be rejected or accepted.
      * "accept" will allow the message signing, "reject" will block it.
@@ -1892,9 +3256,9 @@ export declare const SignSolMessageRuleSchema: z.ZodObject<{
     action: z.ZodEnum<["reject", "accept"]>;
     /**
      * The operation to which this rule applies.
-     * Must be "signSolMessage".
+     * Must be "signEndUserSolMessage".
      */
-    operation: z.ZodLiteral<"signSolMessage">;
+    operation: z.ZodLiteral<"signEndUserSolMessage">;
     /**
      * The set of criteria that must be matched for this rule to apply.
      * Must be compatible with the specified operation type.
@@ -1915,18 +3279,18 @@ export declare const SignSolMessageRuleSchema: z.ZodObject<{
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
-    operation: "signSolMessage";
+    operation: "signEndUserSolMessage";
     criteria: {
         match: string;
         type: "solMessage";
     }[];
 }, {
     action: "reject" | "accept";
-    operation: "signSolMessage";
+    operation: "signEndUserSolMessage";
     criteria: {
         match: string;
         type: "solMessage";
     }[];
 }>;
-export type SignSolMessageRule = z.infer<typeof SignSolMessageRuleSchema>;
+export type SignEndUserSolMessageRule = z.infer<typeof SignEndUserSolMessageRuleSchema>;
 //# sourceMappingURL=solanaSchema.d.ts.map