@coinbase/cdp-sdk/_types/policies/solanaSchema.d.ts

SDK for interacting with the Coinbase Developer Platform Wallet API

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