@coinbase/cdp-sdk 1.31.0 → 1.32.0

package/_types/policies/solanaSchema.d.ts

@@ -0,0 +1,758 @@
+import { z } from "zod";
+/**
+ * Enum for Action types
+ */
+export declare const ActionEnum: z.ZodEnum<["reject", "accept"]>;
+/**
+ * Type representing the possible policy actions.
+ * Determines whether matching the rule will cause a request to be accepted or rejected.
+ */
+export type Action = z.infer<typeof ActionEnum>;
+/**
+ * Enum for SolAddressOperator values
+ */
+export declare const SolAddressOperatorEnum: z.ZodEnum<["in", "not in"]>;
+/**
+ * Type representing the operators that can be used for Solana address comparisons.
+ * These operators determine how transaction addresses are evaluated against a list.
+ */
+export type SolAddressOperator = z.infer<typeof SolAddressOperatorEnum>;
+/**
+ * Enum for SolValueOperator values
+ */
+export declare const SolValueOperatorEnum: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+/**
+ * Type representing the operators that can be used for SOL value comparisons.
+ * These operators determine how transaction SOL values are compared against thresholds.
+ */
+export type SolValueOperator = z.infer<typeof SolValueOperatorEnum>;
+/**
+ * Enum for SplAddressOperator values
+ */
+export declare const SplAddressOperatorEnum: z.ZodEnum<["in", "not in"]>;
+/**
+ * Type representing the operators that can be used for SPL address comparisons.
+ * These operators determine how SPL token transfer recipient addresses are evaluated against a list.
+ */
+export type SplAddressOperator = z.infer<typeof SplAddressOperatorEnum>;
+/**
+ * Enum for SplValueOperator values
+ */
+export declare const SplValueOperatorEnum: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+/**
+ * Type representing the operators that can be used for SPL token value comparisons.
+ * These operators determine how SPL token values are compared against thresholds.
+ */
+export type SplValueOperator = z.infer<typeof SplValueOperatorEnum>;
+/**
+ * Enum for MintAddressOperator values
+ */
+export declare const MintAddressOperatorEnum: z.ZodEnum<["in", "not in"]>;
+/**
+ * Type representing the operators that can be used for mint address comparisons.
+ * These operators determine how token mint addresses are evaluated against a list.
+ */
+export type MintAddressOperator = z.infer<typeof MintAddressOperatorEnum>;
+/**
+ * Schema for Solana address criterions
+ */
+export declare const SolAddressCriterionSchema: 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[];
+}>;
+export type SolAddressCriterion = z.infer<typeof SolAddressCriterionSchema>;
+/**
+ * Schema for SOL value criterions
+ */
+export declare const SolValueCriterionSchema: 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: ">" | ">=" | "<" | "<=" | "==";
+}>;
+export type SolValueCriterion = z.infer<typeof SolValueCriterionSchema>;
+/**
+ * Schema for SPL address criterions
+ */
+export declare const SplAddressCriterionSchema: 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[];
+}>;
+export type SplAddressCriterion = z.infer<typeof SplAddressCriterionSchema>;
+/**
+ * Schema for SPL value criterions
+ */
+export declare const SplValueCriterionSchema: 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: ">" | ">=" | "<" | "<=" | "==";
+}>;
+export type SplValueCriterion = z.infer<typeof SplValueCriterionSchema>;
+/**
+ * Schema for mint address criterions
+ */
+export declare const MintAddressCriterionSchema: 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[];
+}>;
+export type MintAddressCriterion = z.infer<typeof MintAddressCriterionSchema>;
+/**
+ * Schema for criteria used in SignSolTransaction operations
+ */
+export declare const SignSolTransactionCriteriaSchema: 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[];
+}>]>, "many">;
+/**
+ * Type representing a set of criteria for the signSolTransaction operation.
+ * Can contain up to 10 individual criterion objects for Solana addresses, SOL values, SPL addresses, SPL values, and mint addresses.
+ */
+export type SignSolTransactionCriteria = z.infer<typeof SignSolTransactionCriteriaSchema>;
+/**
+ * Schema for criteria used in SendSolTransaction operations
+ */
+export declare const SendSolTransactionCriteriaSchema: 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[];
+}>]>, "many">;
+/**
+ * Type representing a set of criteria for the sendSolTransaction operation.
+ * Can contain up to 10 individual criterion objects for Solana addresses, SOL values, SPL addresses, SPL values, and mint addresses.
+ */
+export type SendSolTransactionCriteria = z.infer<typeof SendSolTransactionCriteriaSchema>;
+/**
+ * Enum for Solana Operation types
+ */
+export declare const SolOperationEnum: z.ZodEnum<["signSolTransaction", "sendSolTransaction"]>;
+/**
+ * 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[];
+    }>]>, "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[];
+    })[];
+}, {
+    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[];
+    })[];
+}>;
+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[];
+    }>]>, "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[];
+    })[];
+}, {
+    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[];
+    })[];
+}>;
+export type SendSolTransactionRule = z.infer<typeof SendSolTransactionRuleSchema>;
+//# sourceMappingURL=solanaSchema.d.ts.map