@beeperbot/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4480 @@
+import { z } from 'zod';
+
+/**
+ * API Base URLs for different environments
+ */
+declare const API_BASE_URLS: {
+    readonly production: "https://beep.works/api/v1/sdk";
+    readonly staging: "https://staging.beep.works/api/v1/sdk";
+    readonly development: "http://localhost:3000/api/v1/sdk";
+};
+type Environment = keyof typeof API_BASE_URLS;
+/**
+ * Default timeout values in milliseconds
+ */
+declare const TIMEOUTS: {
+    /** Default request timeout */
+    readonly DEFAULT: 30000;
+    /** Timeout for quote requests */
+    readonly QUOTE: 10000;
+    /** Timeout for execute requests (longer due to blockchain) */
+    readonly EXECUTE: 60000;
+    /** Timeout for health checks */
+    readonly HEALTH: 5000;
+};
+/**
+ * API Endpoints
+ */
+declare const ENDPOINTS: {
+    readonly HEALTH: "/send/health";
+    readonly QUOTES: "/send/quotes";
+    readonly KEYS: "/keys";
+};
+/**
+ * HTTP Headers
+ */
+declare const HEADERS: {
+    readonly IDEMPOTENCY_KEY: "Idempotency-Key";
+    readonly AUTHORIZATION: "Authorization";
+    readonly REQUEST_ID: "X-Request-Id";
+    readonly CONTENT_TYPE: "Content-Type";
+};
+/**
+ * Retry configuration
+ */
+declare const RETRY_CONFIG: {
+    /** Maximum number of retry attempts */
+    readonly MAX_RETRIES: 3;
+    /** Initial delay before first retry (1 second) */
+    readonly INITIAL_DELAY_MS: 1000;
+    /** Maximum delay between retries (30 seconds) */
+    readonly MAX_DELAY_MS: 30000;
+    /** Multiplier for exponential backoff */
+    readonly BACKOFF_MULTIPLIER: 2;
+    /** Jitter factor to add randomness (0-1) */
+    readonly JITTER_FACTOR: 0.1;
+};
+/**
+ * Quote expiration time in seconds
+ */
+declare const QUOTE_EXPIRATION_SECONDS = 300;
+/**
+ * SDK Version
+ */
+declare const SDK_VERSION = "0.1.0";
+
+/**
+ * Filter Schema for LLM/Agent consumption
+ *
+ * Provides structured descriptions of all available filters
+ * that can be used by LLMs to understand and construct filter queries.
+ */
+interface FilterFieldSchema {
+    /** Field name */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Data type */
+    type: 'number' | 'string' | 'boolean' | 'array' | 'object';
+    /** Example value */
+    example: unknown;
+    /** Whether this field is required */
+    required?: boolean;
+    /** Minimum value (for numbers) */
+    min?: number;
+    /** Maximum value (for numbers) */
+    max?: number;
+    /** Allowed values (for enums) */
+    enum?: string[];
+    /** Item type (for arrays) */
+    items?: FilterFieldSchema;
+    /** Nested schema (for objects) */
+    properties?: Record<string, FilterFieldSchema>;
+}
+interface FilterCategory {
+    /** Category name */
+    name: string;
+    /** Category description */
+    description: string;
+    /** Filters in this category */
+    filters: FilterFieldSchema[];
+}
+/**
+ * Complete filter schema organized by category
+ */
+declare const FILTER_SCHEMA: FilterCategory[];
+/**
+ * Get a flat list of all filter names
+ */
+declare function getAllFilterNames(): string[];
+/**
+ * Get schema for a specific filter
+ */
+declare function getFilterSchema(name: string): FilterFieldSchema | undefined;
+/**
+ * Generate a markdown description of all filters (for LLM prompts)
+ */
+declare function generateFilterDocumentation(): string;
+
+/**
+ * AgentClient - Simplified SDK for AI agents
+ *
+ * Provides a minimal API surface for agents to:
+ * 1. Look up users (username/fid → address)
+ * 2. Get attention prices
+ * 3. Create payment intents
+ *
+ * Agents create intents, users execute payments from any wallet.
+ *
+ * @example
+ * ```typescript
+ * import { AgentClient } from '@beeper/sdk';
+ *
+ * const agent = new AgentClient({
+ *   apiKey: process.env.BEEPER_API_KEY,
+ * });
+ *
+ * // Look up a user
+ * const user = await agent.lookup('dwr.eth');
+ *
+ * // Create a payment intent
+ * const intent = await agent.createIntent({
+ *   to: 'dwr.eth',
+ *   amount: '$5',
+ *   message: 'Thanks for the help!',
+ * });
+ *
+ * // Agent tells user:
+ * // "Send 5 USDC to 0x1234... on Base"
+ * ```
+ */
+
+/** Agent client configuration */
+interface AgentClientConfig {
+    /** API key for authentication */
+    apiKey: string;
+    /** Environment (production, staging, development) */
+    environment?: Environment;
+    /** Custom base URL (overrides environment) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds */
+    timeoutMs?: number;
+    /** Custom fetch implementation */
+    fetch?: typeof fetch;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/** User lookup result */
+interface User {
+    /** Internal user ID */
+    id: string;
+    /** Farcaster ID (if applicable) */
+    fid?: number;
+    /** Username */
+    username: string;
+    /** Display name */
+    displayName?: string;
+    /** Profile picture URL */
+    pfpUrl?: string;
+    /** Platform (farcaster, twitter, etc.) */
+    platform: string;
+    /** Verified wallet address for receiving payments */
+    walletAddress?: string;
+    /** Current attention price in USD */
+    attentionPriceUsd: string;
+    /** User's follower count */
+    followerCount?: number;
+    /** User's Neynar score (0-1) */
+    neynarScore?: number;
+}
+/** Payment intent - the instruction for the user to execute */
+interface PaymentIntent {
+    /** Unique intent ID for tracking */
+    intentId: string;
+    /** Recipient wallet address */
+    recipient: string;
+    /** Amount in token's smallest unit (e.g., USDC has 6 decimals) */
+    amount: string;
+    /** Amount formatted for display (e.g., "5.00 USDC") */
+    amountFormatted: string;
+    /** Token contract address */
+    tokenAddress: string;
+    /** Token symbol (e.g., "USDC") */
+    tokenSymbol: string;
+    /** Token decimals */
+    tokenDecimals: number;
+    /** Chain ID (e.g., 8453 for Base) */
+    chainId: number;
+    /** Chain name for display */
+    chainName: string;
+    /** Optional message/memo */
+    message?: string;
+    /** Resolved recipient info */
+    recipientInfo: {
+        username: string;
+        displayName?: string;
+        fid?: number;
+    };
+    /** Human-readable instruction */
+    instruction: string;
+    /** Deep link to beep.works (optional, for convenience) */
+    deepLink?: string;
+    /** Expiration timestamp */
+    expiresAt: string;
+}
+/** Input for creating a payment intent */
+interface CreateIntentInput {
+    /** Recipient identifier (username, fid, or address) */
+    to: string | number;
+    /** Amount in USD (e.g., "$5", "5", or "5.00") */
+    amount: string;
+    /** Optional message to include */
+    message?: string;
+    /** Preferred chain (defaults to Base) */
+    chainId?: number;
+    /** Preferred token (defaults to USDC) */
+    tokenSymbol?: string;
+}
+/** Attention price info */
+interface AttentionPrice {
+    /** User identifier */
+    userId: string;
+    /** Username */
+    username: string;
+    /** Current attention price in USD */
+    priceUsd: string;
+    /** Price in USDC smallest unit */
+    priceUsdc: string;
+    /** Minimum price for guaranteed delivery */
+    minimumPriceUsd: string;
+}
+/** Simple JSON-based filter input (agent-friendly) */
+interface SimpleFilters {
+    platform?: 'all' | 'farcaster' | 'twitter';
+    activeInLastDays?: number;
+    minCastCount?: number;
+    neynarScoreMin?: number;
+    neynarScoreMax?: number;
+    quotientScoreMin?: number;
+    quotientScoreMax?: number;
+    spamLabel?: 'not_spam_only' | 'spam_only' | 'all';
+    verifiedOnly?: boolean;
+    minFollowers?: number;
+    maxFollowers?: number;
+    followersOf?: number;
+    mutualsWith?: number;
+    signalTokens?: string[];
+    tokenHolders?: Array<{
+        tokenAddress: string;
+        chainId: number;
+        minBalance?: string;
+    }>;
+    hasBaseWallet?: boolean;
+    hasVerifiedWallet?: boolean;
+    maxAttentionPriceUsd?: number;
+    minBatteryPercentage?: number;
+    hasRechargedInLastDays?: number;
+    excludePingedToday?: boolean;
+    countries?: string[];
+    timezones?: Array<{
+        offset: number;
+        range?: number;
+    }>;
+    fids?: number[];
+    userIds?: string[];
+    orderBy?: 'attention_price_asc' | 'attention_price_desc' | 'neynar_score_desc' | 'followers_desc' | 'followers_asc' | 'recent_activity' | 'battery_desc' | 'random';
+}
+/** Estimate request input */
+interface EstimateInput {
+    /** Filter criteria */
+    filters: SimpleFilters;
+    /** Budget in USD (e.g., "$100" or "100") */
+    budget: string;
+    /** Optional message to include (affects cost) */
+    message?: string;
+}
+/** Estimate result */
+interface EstimateResult {
+    /** Number of recipients matching filters within budget */
+    recipientCount: number;
+    /** Total cost in USD */
+    totalCostUsd: string;
+    /** Average price per recipient */
+    avgPriceUsd: string;
+    /** Minimum price in result set */
+    minPriceUsd: string;
+    /** Maximum price in result set */
+    maxPriceUsd: string;
+    /** Budget remaining after all recipients */
+    remainingBudgetUsd: string;
+    /** Whether budget is sufficient for at least one recipient */
+    budgetSufficient: boolean;
+}
+/** Preview request input */
+interface PreviewInput {
+    /** Filter criteria */
+    filters: SimpleFilters;
+    /** Number of users to preview (max 20) */
+    limit?: number;
+}
+/** Preview user */
+interface PreviewUser {
+    /** Username */
+    username: string;
+    /** Display name */
+    displayName?: string;
+    /** Farcaster ID */
+    fid?: number;
+    /** Attention price in USD */
+    priceUsd: string;
+    /** Follower count */
+    followerCount?: number;
+    /** Neynar score */
+    neynarScore?: number;
+    /** Profile picture URL */
+    pfpUrl?: string;
+}
+/** Preview result */
+interface PreviewResult {
+    /** Sample users matching filters */
+    users: PreviewUser[];
+    /** Total count of matching users (not just preview) */
+    totalCount: number;
+    /** Whether there are more users beyond the preview */
+    hasMore: boolean;
+}
+/** Bulk intent input */
+interface BulkIntentInput {
+    /** Filter criteria (will create intents for all matching users) */
+    filters: SimpleFilters;
+    /** Budget in USD */
+    budget: string;
+    /** Message to include */
+    message?: string;
+    /** Chain ID (default: Base = 8453) */
+    chainId?: number;
+}
+/** Bulk intent result */
+interface BulkIntentResult {
+    /** Unique bulk intent ID */
+    bulkIntentId: string;
+    /** Total number of recipients */
+    recipientCount: number;
+    /** Total amount in USDC smallest unit */
+    totalAmount: string;
+    /** Total amount formatted */
+    totalAmountFormatted: string;
+    /** Individual payment instructions */
+    payments: Array<{
+        recipient: string;
+        amount: string;
+        username: string;
+    }>;
+    /** Human-readable summary */
+    summary: string;
+    /** Chain info */
+    chainId: number;
+    chainName: string;
+    tokenAddress: string;
+    tokenSymbol: string;
+    /** Expiration */
+    expiresAt: string;
+}
+/**
+ * AgentClient - Simplified client for AI agents
+ *
+ * Focuses on the core agent workflow:
+ * 1. Look up users
+ * 2. Check prices
+ * 3. Create payment intents
+ */
+declare class AgentClient {
+    private readonly http;
+    private readonly _debug;
+    constructor(config: AgentClientConfig);
+    /**
+     * Look up a user by username, FID, or wallet address
+     *
+     * @param identifier - Username (e.g., "dwr.eth"), FID (e.g., 3), or address
+     * @returns User information including wallet address and attention price
+     *
+     * @example
+     * ```typescript
+     * const user = await agent.lookup('dwr.eth');
+     * console.log(user.walletAddress); // "0x1234..."
+     * console.log(user.attentionPriceUsd); // "0.05"
+     * ```
+     */
+    lookup(identifier: string | number): Promise<User>;
+    /**
+     * Get the attention price for a user
+     *
+     * @param identifier - Username, FID, or address
+     * @returns Current attention price information
+     *
+     * @example
+     * ```typescript
+     * const price = await agent.getPrice('dwr.eth');
+     * console.log(`Attention price: ${price.priceUsd}`);
+     * ```
+     */
+    getPrice(identifier: string | number): Promise<AttentionPrice>;
+    /**
+     * Create a payment intent
+     *
+     * This does NOT execute the payment. It returns the information
+     * needed for the user to execute the payment from any wallet.
+     *
+     * @param input - Payment intent parameters
+     * @returns Payment intent with recipient address and amount
+     *
+     * @example
+     * ```typescript
+     * const intent = await agent.createIntent({
+     *   to: 'dwr.eth',
+     *   amount: '$5',
+     *   message: 'Thanks!',
+     * });
+     *
+     * // Tell the user:
+     * console.log(intent.instruction);
+     * // "Send 5 USDC to 0x1234... on Base"
+     * ```
+     */
+    createIntent(input: CreateIntentInput): Promise<PaymentIntent>;
+    /**
+     * Convenience method to create a human-readable payment instruction
+     *
+     * @param input - Payment intent parameters
+     * @returns Human-readable instruction string
+     *
+     * @example
+     * ```typescript
+     * const instruction = await agent.getPaymentInstruction({
+     *   to: 'dwr.eth',
+     *   amount: '$5',
+     * });
+     * // "Send 5 USDC to 0x1a2b3c... on Base (to @dwr)"
+     * ```
+     */
+    getPaymentInstruction(input: CreateIntentInput): Promise<string>;
+    /**
+     * Estimate how many recipients match filters within a budget
+     *
+     * @param input - Filters and budget
+     * @returns Estimate with recipient count, costs, and budget analysis
+     *
+     * @example
+     * ```typescript
+     * const estimate = await agent.estimate({
+     *   filters: {
+     *     platform: 'farcaster',
+     *     minFollowers: 1000,
+     *     signalTokens: ['0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed'],
+     *   },
+     *   budget: '$100',
+     * });
+     * console.log(`Can reach ${estimate.recipientCount} people`);
+     * console.log(`Total cost: ${estimate.totalCostUsd}`);
+     * ```
+     */
+    estimate(input: EstimateInput): Promise<EstimateResult>;
+    /**
+     * Preview sample users matching filters
+     *
+     * @param input - Filters and limit
+     * @returns Sample users and total count
+     *
+     * @example
+     * ```typescript
+     * const preview = await agent.preview({
+     *   filters: { minFollowers: 1000 },
+     *   limit: 5,
+     * });
+     * console.log(`Found ${preview.totalCount} users`);
+     * preview.users.forEach(u => {
+     *   console.log(`@${u.username} - ${u.priceUsd}`);
+     * });
+     * ```
+     */
+    preview(input: PreviewInput): Promise<PreviewResult>;
+    /**
+     * Create bulk payment intents for multiple recipients
+     *
+     * @param input - Filters, budget, and message
+     * @returns Bulk intent with all payment instructions
+     *
+     * @example
+     * ```typescript
+     * const bulk = await agent.createBulkIntent({
+     *   filters: { signalTokens: ['0x...'] },
+     *   budget: '$100',
+     *   message: 'GM holders!',
+     * });
+     * console.log(bulk.summary);
+     * // "Send to 50 recipients for total 45.00 USDC on Base"
+     * ```
+     */
+    createBulkIntent(input: BulkIntentInput): Promise<BulkIntentResult>;
+    /**
+     * Get filter schema documentation for LLMs
+     *
+     * Returns structured information about all available filters
+     * that can be used in system prompts or tool descriptions.
+     *
+     * @returns Filter schema categories
+     *
+     * @example
+     * ```typescript
+     * const schema = agent.describeFilters();
+     * // Use in LLM prompt:
+     * // "Available filters: " + JSON.stringify(schema)
+     * ```
+     */
+    describeFilters(): FilterCategory[];
+    /**
+     * Get filter documentation as markdown
+     *
+     * Useful for including in LLM system prompts.
+     *
+     * @returns Markdown documentation of all filters
+     *
+     * @example
+     * ```typescript
+     * const docs = agent.getFilterDocumentation();
+     * // Include in system prompt for LLM
+     * ```
+     */
+    getFilterDocumentation(): string;
+}
+
+/**
+ * BeeperClient - Main SDK client for the Beeper API
+ *
+ * Handles quote creation, deposit confirmation, execution triggering,
+ * and receipt polling while keeping all pricing/fee logic server-side.
+ */
+
+/** Filter expression for recipient selection */
+type FilterExpression$2 = Record<string, unknown>;
+/** Draft input for creating a send */
+interface DraftInput$1 {
+    filter: FilterExpression$2;
+    tokenAddress: string;
+    chainId: number;
+    amountPerRecipient: string;
+    budgetCap: string;
+    memo?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+/** Local draft object (not yet quoted) */
+interface Draft$2 {
+    id: string;
+    input: DraftInput$1;
+    createdAt: string;
+}
+/** Quote status values */
+type QuoteStatus$2 = 'pending' | 'deposit_confirmed' | 'executing' | 'completed' | 'expired' | 'failed';
+/** Server-generated quote with pricing */
+interface Quote$1 {
+    id: string;
+    status: QuoteStatus$2;
+    recipientCount: number;
+    totalAmount: string;
+    protocolFee: string;
+    depositAmount: string;
+    depositAddress: string;
+    depositChainId: number;
+    depositTokenAddress: string;
+    expiresAt: string;
+    input: DraftInput$1;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Options for creating a quote */
+interface QuoteOptions$1 {
+    ttlSeconds?: number;
+}
+/** Reward type for attention marketplace */
+type RewardType$1 = 'guaranteed' | 'lottery' | 'fcfs';
+/** Input for creating an attention marketplace quote */
+interface AttentionQuoteInput {
+    /** The message to send (1-1000 chars) */
+    message: string;
+    /** Target specific FIDs (optional, max 1000) */
+    recipientFids?: number[];
+    /** Filter expression for targeting (optional, used if recipientFids not provided) */
+    filter?: FilterExpression$2;
+    /** Budget in USD (e.g., "10.00") */
+    budgetUSD: string;
+    /** Reward type: guaranteed (default), lottery, or fcfs */
+    rewardType?: RewardType$1;
+    /** Optional memo (max 256 chars) */
+    memo?: string;
+    /** Optional metadata (max 4KB JSON) */
+    metadata?: Record<string, unknown>;
+}
+/** Attention marketplace quote response */
+interface AttentionQuote {
+    id: string;
+    status: QuoteStatus$2;
+    recipientCount: number;
+    /** Total amount in USD (may be undefined for token-based quotes) */
+    totalAmountUSD?: string;
+    /** Protocol fee in USD */
+    protocolFeeUSD?: string;
+    /** Deposit amount in USD */
+    depositAmountUSD?: string;
+    /** Total amount in wei (for token-based quotes) */
+    totalAmount?: string;
+    /** Protocol fee in wei */
+    protocolFee?: string;
+    /** Deposit amount in wei */
+    depositAmount?: string;
+    /** Deposit address */
+    depositAddress?: string;
+    /** Deposit chain ID */
+    depositChainId?: number;
+    /** Deposit token address */
+    depositTokenAddress?: string;
+    expiresAt: string;
+    input: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Result of deposit confirmation */
+interface ConfirmResult {
+    quoteId: string;
+    status: 'confirmed' | 'pending_verification';
+    detectedAmount: string;
+    sufficient: boolean;
+    blockNumber: number;
+    confirmedAt: string;
+}
+/** Result of execution trigger */
+interface ExecuteResult$1 {
+    quoteId: string;
+    status: 'executing' | 'queued';
+    estimatedCompletionAt: string;
+    batchId: string;
+}
+/** Individual transaction in a receipt */
+interface ReceiptTransaction$1 {
+    recipient: string;
+    amount: string;
+    txHash: string | null;
+    status: 'success' | 'failed';
+    error?: string | undefined;
+}
+/** Final receipt after execution */
+interface Receipt$1 {
+    quoteId: string;
+    status: 'completed' | 'partial' | 'failed';
+    successCount: number;
+    failureCount: number;
+    totalSent: string;
+    refundAmount: string;
+    refundTxHash?: string | undefined;
+    transactions: ReceiptTransaction$1[];
+    completedAt: string;
+}
+/** API health status */
+interface Health$1 {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    version: string;
+    timestamp: string;
+    services: {
+        database: 'up' | 'down';
+        queue: 'up' | 'down';
+        oracle: 'up' | 'down';
+    };
+}
+/** Client configuration */
+interface BeeperClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    environment?: Environment;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+    debug?: boolean;
+}
+/** Poll options */
+interface PollOptions$1 {
+    maxAttempts?: number;
+    intervalMs?: number;
+    onPoll?: (quote: Quote$1) => void;
+}
+/**
+ * BeeperClient - Main SDK client for the Beeper protocol
+ *
+ * @example
+ * ```typescript
+ * const client = new BeeperClient({
+ *   apiKey: process.env.BEEPER_API_KEY,
+ * });
+ *
+ * // Create a draft
+ * const draft = client.createDraft({
+ *   filter: { hasTag: 'vip' },
+ *   tokenAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+ *   chainId: 8453,
+ *   amountPerRecipient: '1000000',
+ *   budgetCap: '100000000',
+ * });
+ *
+ * // Get a quote
+ * const quote = await client.createQuote(draft);
+ * ```
+ */
+declare class BeeperClient {
+    private readonly http;
+    constructor(config: BeeperClientConfig);
+    /**
+     * Validates client configuration
+     */
+    private validateConfig;
+    /**
+     * Creates a local draft. Does NOT make a network request.
+     * @param input - The draft input parameters
+     * @returns A draft object with a generated ID
+     */
+    createDraft(input: DraftInput$1): Draft$2;
+    /**
+     * Validates draft input parameters
+     */
+    private validateDraftInput;
+    /**
+     * Submits draft to server and receives a priced quote
+     * @param draft - The draft to quote
+     * @param opts - Optional quote options
+     * @returns A quote with server-computed pricing
+     */
+    createQuote(draft: Draft$2, opts?: QuoteOptions$1): Promise<Quote$1>;
+    /**
+     * Creates an attention marketplace quote (message-based send)
+     * @param input - Attention quote input with message, recipients, and budget
+     * @param opts - Optional quote options
+     * @returns An attention quote with server-computed pricing
+     *
+     * @example
+     * ```typescript
+     * const quote = await client.createAttentionQuote({
+     *   message: "Check out our new feature!",
+     *   filter: FilterBuilder.and([
+     *     FilterBuilder.platform('farcaster'),
+     *     FilterBuilder.activeInLastDays(7),
+     *   ]).toJSON(),
+     *   budgetUSD: "50.00",
+     *   rewardType: 'guaranteed',
+     * });
+     * ```
+     */
+    createAttentionQuote(input: AttentionQuoteInput, opts?: QuoteOptions$1): Promise<AttentionQuote>;
+    /**
+     * Retrieves an existing quote by ID
+     * @param quoteId - The quote ID
+     * @returns The quote
+     */
+    getQuote(quoteId: string): Promise<Quote$1>;
+    /**
+     * Confirms that deposit has been made
+     * @param quoteId - The quote ID
+     * @param params - Confirmation parameters including txHash and idempotencyKey
+     * @returns Confirmation result
+     */
+    confirmDeposit(quoteId: string, params: {
+        txHash: string;
+        idempotencyKey: string;
+    }): Promise<ConfirmResult>;
+    /**
+     * Triggers execution of the send
+     * @param quoteId - The quote ID
+     * @param params - Execution parameters including idempotencyKey
+     * @returns Execution result
+     */
+    executeSend(quoteId: string, params: {
+        idempotencyKey: string;
+    }): Promise<ExecuteResult$1>;
+    /**
+     * Gets the receipt for a completed (or failed) execution
+     * @param quoteId - The quote ID
+     * @returns The receipt
+     */
+    getReceiptByQuoteId(quoteId: string): Promise<Receipt$1>;
+    /**
+     * Polls until execution completes, then returns receipt
+     * @param quoteId - The quote ID
+     * @param opts - Polling options
+     * @returns The receipt when execution completes
+     */
+    pollUntilCompleteByQuoteId(quoteId: string, opts?: PollOptions$1): Promise<Receipt$1>;
+    /**
+     * Checks API health status
+     * @returns Health status
+     */
+    health(): Promise<Health$1>;
+    /**
+     * Sleep helper for polling
+     */
+    private sleep;
+}
+
+/**
+ * Supported networks
+ */
+declare const NetworkSchema: z.ZodEnum<["ethereum", "polygon", "base", "arbitrum", "optimism"]>;
+/**
+ * Supported tokens
+ */
+declare const TokenTypeSchema: z.ZodEnum<["USDC", "USDT", "ETH", "MATIC"]>;
+/**
+ * Distribution strategies
+ */
+declare const DistributionStrategySchema: z.ZodEnum<["equal", "weighted", "proportional"]>;
+/**
+ * Draft status
+ */
+declare const DraftStatusSchema: z.ZodEnum<["draft", "quoted", "executed"]>;
+/**
+ * Draft input schema - for creating new drafts
+ */
+declare const DraftInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    amount: z.ZodString;
+    token: z.ZodEnum<["USDC", "USDT", "ETH", "MATIC"]>;
+    network: z.ZodEnum<["ethereum", "polygon", "base", "arbitrum", "optimism"]>;
+    filter: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+    strategy: z.ZodEnum<["equal", "weighted", "proportional"]>;
+    weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    amount: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    strategy: "equal" | "weighted" | "proportional";
+    filter?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    weights?: Record<string, number> | undefined;
+}, {
+    name: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    amount: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    strategy: "equal" | "weighted" | "proportional";
+    filter?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    weights?: Record<string, number> | undefined;
+}>;
+/**
+ * Full draft schema - includes server-generated fields
+ */
+declare const DraftSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    amount: z.ZodString;
+    token: z.ZodEnum<["USDC", "USDT", "ETH", "MATIC"]>;
+    network: z.ZodEnum<["ethereum", "polygon", "base", "arbitrum", "optimism"]>;
+    filter: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+    strategy: z.ZodEnum<["equal", "weighted", "proportional"]>;
+    weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    status: z.ZodEnum<["draft", "quoted", "executed"]>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    status: "draft" | "quoted" | "executed";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    amount: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    strategy: "equal" | "weighted" | "proportional";
+    filter?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    weights?: Record<string, number> | undefined;
+}, {
+    name: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    status: "draft" | "quoted" | "executed";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    amount: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    strategy: "equal" | "weighted" | "proportional";
+    filter?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    weights?: Record<string, number> | undefined;
+}>;
+/**
+ * Draft update schema - partial update
+ */
+declare const DraftUpdateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodEnum<["USDC", "USDT", "ETH", "MATIC"]>>;
+    network: z.ZodOptional<z.ZodEnum<["ethereum", "polygon", "base", "arbitrum", "optimism"]>>;
+    filter: z.ZodOptional<z.ZodType<unknown, z.ZodTypeDef, unknown>>;
+    strategy: z.ZodOptional<z.ZodEnum<["equal", "weighted", "proportional"]>>;
+    weights: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+    metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    filter?: unknown;
+    network?: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    amount?: string | undefined;
+    token?: "USDC" | "USDT" | "ETH" | "MATIC" | undefined;
+    strategy?: "equal" | "weighted" | "proportional" | undefined;
+    weights?: Record<string, number> | undefined;
+}, {
+    name?: string | undefined;
+    filter?: unknown;
+    network?: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    amount?: string | undefined;
+    token?: "USDC" | "USDT" | "ETH" | "MATIC" | undefined;
+    strategy?: "equal" | "weighted" | "proportional" | undefined;
+    weights?: Record<string, number> | undefined;
+}>;
+/**
+ * Validate draft input
+ */
+declare function validateDraftInput$1(input: unknown): z.SafeParseReturnType<{
+    name: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    amount: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    strategy: "equal" | "weighted" | "proportional";
+    filter?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    weights?: Record<string, number> | undefined;
+}, {
+    name: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    amount: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    strategy: "equal" | "weighted" | "proportional";
+    filter?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    weights?: Record<string, number> | undefined;
+}>;
+/**
+ * Parse draft input
+ */
+declare function parseDraftInput(input: unknown): {
+    name: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    amount: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    strategy: "equal" | "weighted" | "proportional";
+    filter?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    weights?: Record<string, number> | undefined;
+};
+/**
+ * Validate draft response
+ */
+declare function validateDraft(draft: unknown): z.SafeParseReturnType<{
+    name: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    status: "draft" | "quoted" | "executed";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    amount: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    strategy: "equal" | "weighted" | "proportional";
+    filter?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    weights?: Record<string, number> | undefined;
+}, {
+    name: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    status: "draft" | "quoted" | "executed";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    amount: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    strategy: "equal" | "weighted" | "proportional";
+    filter?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    weights?: Record<string, number> | undefined;
+}>;
+/**
+ * Parse draft response
+ */
+declare function parseDraft(draft: unknown): {
+    name: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    status: "draft" | "quoted" | "executed";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    amount: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    strategy: "equal" | "weighted" | "proportional";
+    filter?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    weights?: Record<string, number> | undefined;
+};
+
+type Draft$1 = z.infer<typeof DraftSchema>;
+type DraftInput = z.infer<typeof DraftInputSchema>;
+/**
+ * Create a new draft from input (pure function, no API calls)
+ *
+ * @param input - The draft input configuration
+ * @returns A Draft object with generated ID and timestamps
+ * @throws BeeperError if input validation fails
+ */
+declare function createDraft(input: DraftInput): Draft$1;
+/**
+ * Validate draft input using Zod schema
+ *
+ * @param input - Unknown input to validate
+ * @returns Validated DraftInput
+ * @throws BeeperError if validation fails
+ */
+declare function validateDraftInput(input: unknown): DraftInput;
+/**
+ * Update an existing draft with new values
+ *
+ * @param draft - The existing draft to update
+ * @param updates - Partial updates to apply
+ * @returns Updated draft with new updatedAt timestamp
+ */
+declare function updateDraft(draft: Draft$1, updates: Partial<DraftInput>): Draft$1;
+/**
+ * Check if a draft is ready for quoting
+ *
+ * @param draft - The draft to check
+ * @returns true if the draft can be quoted
+ */
+declare function isReadyForQuote(draft: Draft$1): boolean;
+
+/**
+ * Retry options for HTTP requests
+ */
+interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Initial delay in milliseconds before first retry (default: 1000) */
+    initialDelayMs?: number;
+    /** Maximum delay in milliseconds between retries (default: 30000) */
+    maxDelayMs?: number;
+    /** Multiplier for exponential backoff (default: 2) */
+    backoffMultiplier?: number;
+    /** Jitter factor to add randomness (0-1, default: 0.1) */
+    jitterFactor?: number;
+}
+/**
+ * HTTP request options
+ */
+interface HttpRequestOptions {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    endpoint: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    timeout?: number;
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+    /** Retry configuration (set to false to disable retries) */
+    retry?: RetryOptions | false;
+    /** Query parameters to append to URL */
+    params?: Record<string, string | number | boolean | undefined>;
+}
+/**
+ * HTTP response wrapper
+ */
+interface HttpResponse<T> {
+    data: T;
+    status: number;
+    headers: Headers;
+    requestId?: string | undefined;
+    /** Number of retry attempts made */
+    retryCount: number;
+    /** Total time taken including retries (ms) */
+    totalTimeMs: number;
+}
+/**
+ * HTTP client configuration
+ */
+interface HttpClientConfig {
+    apiKey: string;
+    baseUrl: string;
+    timeout: number;
+    fetch: typeof fetch;
+    debug: boolean;
+}
+/**
+ * Create HTTP client configuration from SDK config
+ */
+declare function createHttpConfig(options: {
+    apiKey: string;
+    environment?: Environment;
+    baseUrl?: string;
+    timeout?: number;
+    fetch?: typeof fetch;
+    debug?: boolean;
+}): HttpClientConfig;
+/**
+ * HTTP client for making API requests
+ */
+declare class HttpClient {
+    private readonly config;
+    constructor(config: HttpClientConfig);
+    /**
+     * Check if an HTTP status code is retryable
+     * - 5xx server errors
+     * - 429 rate limit errors
+     * Does NOT retry 4xx errors (except 429)
+     */
+    private isRetryableStatus;
+    /**
+     * Check if an error is retryable (network errors, timeouts)
+     */
+    private isRetryableError;
+    /**
+     * Calculate delay with exponential backoff and jitter
+     */
+    private calculateDelay;
+    /**
+     * Sleep for a given number of milliseconds
+     */
+    private sleep;
+    /**
+     * Get default retry configuration
+     */
+    private getRetryConfig;
+    /**
+     * Make an HTTP request with validation and automatic retry
+     */
+    request<T>(options: HttpRequestOptions, responseSchema?: z.ZodType<T>): Promise<HttpResponse<T>>;
+    /**
+     * GET request helper
+     */
+    get<T>(endpoint: string, options?: Partial<HttpRequestOptions>, schema?: z.ZodType<T>): Promise<HttpResponse<T>>;
+    /**
+     * POST request helper
+     */
+    post<T>(endpoint: string, body?: unknown, options?: Partial<HttpRequestOptions>, schema?: z.ZodType<T>): Promise<HttpResponse<T>>;
+    /**
+     * PUT request helper
+     */
+    put<T>(endpoint: string, body?: unknown, options?: Partial<HttpRequestOptions>, schema?: z.ZodType<T>): Promise<HttpResponse<T>>;
+    /**
+     * PATCH request helper
+     */
+    patch<T>(endpoint: string, body?: unknown, options?: Partial<HttpRequestOptions>, schema?: z.ZodType<T>): Promise<HttpResponse<T>>;
+    /**
+     * DELETE request helper
+     */
+    delete<T>(endpoint: string, options?: Partial<HttpRequestOptions>, schema?: z.ZodType<T>): Promise<HttpResponse<T>>;
+    /**
+     * Build request headers
+     */
+    private buildHeaders;
+    /**
+     * Sanitize headers for logging (redact sensitive values)
+     */
+    private sanitizeHeaders;
+    /**
+     * Safely parse JSON response
+     */
+    private safeParseJson;
+    /**
+     * Merge two abort signals
+     */
+    private mergeSignals;
+}
+/**
+ * Generate a unique idempotency key
+ */
+declare function generateIdempotencyKey(): string;
+
+/**
+ * Gas tier options
+ */
+declare const GasTierSchema: z.ZodEnum<["slow", "standard", "fast"]>;
+/**
+ * Quote options schema
+ */
+declare const QuoteOptionsSchema: z.ZodObject<{
+    draftId: z.ZodString;
+    amount: z.ZodOptional<z.ZodString>;
+    gasTier: z.ZodOptional<z.ZodEnum<["slow", "standard", "fast"]>>;
+    slippageTolerance: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    draftId: string;
+    amount?: string | undefined;
+    gasTier?: "slow" | "standard" | "fast" | undefined;
+    slippageTolerance?: number | undefined;
+}, {
+    draftId: string;
+    amount?: string | undefined;
+    gasTier?: "slow" | "standard" | "fast" | undefined;
+    slippageTolerance?: number | undefined;
+}>;
+/**
+ * Quote recipient schema
+ */
+declare const QuoteRecipientSchema: z.ZodObject<{
+    address: z.ZodString;
+    amount: z.ZodString;
+    share: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    address: string;
+    share: number;
+}, {
+    amount: string;
+    address: string;
+    share: number;
+}>;
+/**
+ * Quote schema
+ */
+declare const QuoteSchema: z.ZodObject<{
+    id: z.ZodString;
+    draftId: z.ZodString;
+    totalAmount: z.ZodString;
+    estimatedGas: z.ZodString;
+    gasPrice: z.ZodString;
+    networkFee: z.ZodString;
+    platformFee: z.ZodString;
+    totalCost: z.ZodString;
+    token: z.ZodEnum<["USDC", "USDT", "ETH", "MATIC"]>;
+    network: z.ZodEnum<["ethereum", "polygon", "base", "arbitrum", "optimism"]>;
+    recipients: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        amount: z.ZodString;
+        share: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        amount: string;
+        address: string;
+        share: number;
+    }, {
+        amount: string;
+        address: string;
+        share: number;
+    }>, "many">;
+    recipientCount: z.ZodNumber;
+    expiresAt: z.ZodString;
+    createdAt: z.ZodString;
+    isValid: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    id: string;
+    recipientCount: number;
+    totalAmount: string;
+    expiresAt: string;
+    createdAt: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    draftId: string;
+    estimatedGas: string;
+    gasPrice: string;
+    networkFee: string;
+    platformFee: string;
+    totalCost: string;
+    recipients: {
+        amount: string;
+        address: string;
+        share: number;
+    }[];
+    isValid: boolean;
+}, {
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    id: string;
+    recipientCount: number;
+    totalAmount: string;
+    expiresAt: string;
+    createdAt: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    draftId: string;
+    estimatedGas: string;
+    gasPrice: string;
+    networkFee: string;
+    platformFee: string;
+    totalCost: string;
+    recipients: {
+        amount: string;
+        address: string;
+        share: number;
+    }[];
+    isValid: boolean;
+}>;
+/**
+ * Confirm result schema
+ */
+declare const ConfirmResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    invalidReason: z.ZodOptional<z.ZodString>;
+    currentGasEstimate: z.ZodString;
+    priceChange: z.ZodString;
+    canExecute: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    valid: boolean;
+    currentGasEstimate: string;
+    priceChange: string;
+    canExecute: boolean;
+    invalidReason?: string | undefined;
+}, {
+    valid: boolean;
+    currentGasEstimate: string;
+    priceChange: string;
+    canExecute: boolean;
+    invalidReason?: string | undefined;
+}>;
+/**
+ * Execute result status
+ */
+declare const ExecuteStatusSchema: z.ZodEnum<["pending", "confirmed", "failed"]>;
+/**
+ * Execute result schema
+ */
+declare const ExecuteResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    quoteId: z.ZodString;
+    transactionHash: z.ZodString;
+    status: z.ZodEnum<["pending", "confirmed", "failed"]>;
+    blockNumber: z.ZodOptional<z.ZodNumber>;
+    initiatedAt: z.ZodString;
+    confirmedAt: z.ZodOptional<z.ZodString>;
+    confirmations: z.ZodNumber;
+    receiptId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    quoteId: string;
+    status: "pending" | "failed" | "confirmed";
+    id: string;
+    transactionHash: string;
+    initiatedAt: string;
+    confirmations: number;
+    blockNumber?: number | undefined;
+    confirmedAt?: string | undefined;
+    receiptId?: string | undefined;
+}, {
+    quoteId: string;
+    status: "pending" | "failed" | "confirmed";
+    id: string;
+    transactionHash: string;
+    initiatedAt: string;
+    confirmations: number;
+    blockNumber?: number | undefined;
+    confirmedAt?: string | undefined;
+    receiptId?: string | undefined;
+}>;
+/**
+ * Validate quote options
+ */
+declare function validateQuoteOptions(options: unknown): z.SafeParseReturnType<{
+    draftId: string;
+    amount?: string | undefined;
+    gasTier?: "slow" | "standard" | "fast" | undefined;
+    slippageTolerance?: number | undefined;
+}, {
+    draftId: string;
+    amount?: string | undefined;
+    gasTier?: "slow" | "standard" | "fast" | undefined;
+    slippageTolerance?: number | undefined;
+}>;
+/**
+ * Parse quote options
+ */
+declare function parseQuoteOptions(options: unknown): {
+    draftId: string;
+    amount?: string | undefined;
+    gasTier?: "slow" | "standard" | "fast" | undefined;
+    slippageTolerance?: number | undefined;
+};
+/**
+ * Validate quote response
+ */
+declare function validateQuote(quote: unknown): z.SafeParseReturnType<{
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    id: string;
+    recipientCount: number;
+    totalAmount: string;
+    expiresAt: string;
+    createdAt: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    draftId: string;
+    estimatedGas: string;
+    gasPrice: string;
+    networkFee: string;
+    platformFee: string;
+    totalCost: string;
+    recipients: {
+        amount: string;
+        address: string;
+        share: number;
+    }[];
+    isValid: boolean;
+}, {
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    id: string;
+    recipientCount: number;
+    totalAmount: string;
+    expiresAt: string;
+    createdAt: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    draftId: string;
+    estimatedGas: string;
+    gasPrice: string;
+    networkFee: string;
+    platformFee: string;
+    totalCost: string;
+    recipients: {
+        amount: string;
+        address: string;
+        share: number;
+    }[];
+    isValid: boolean;
+}>;
+/**
+ * Parse quote response
+ */
+declare function parseQuote(quote: unknown): {
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    id: string;
+    recipientCount: number;
+    totalAmount: string;
+    expiresAt: string;
+    createdAt: string;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    draftId: string;
+    estimatedGas: string;
+    gasPrice: string;
+    networkFee: string;
+    platformFee: string;
+    totalCost: string;
+    recipients: {
+        amount: string;
+        address: string;
+        share: number;
+    }[];
+    isValid: boolean;
+};
+/**
+ * Validate execute result
+ */
+declare function validateExecuteResult(result: unknown): z.SafeParseReturnType<{
+    quoteId: string;
+    status: "pending" | "failed" | "confirmed";
+    id: string;
+    transactionHash: string;
+    initiatedAt: string;
+    confirmations: number;
+    blockNumber?: number | undefined;
+    confirmedAt?: string | undefined;
+    receiptId?: string | undefined;
+}, {
+    quoteId: string;
+    status: "pending" | "failed" | "confirmed";
+    id: string;
+    transactionHash: string;
+    initiatedAt: string;
+    confirmations: number;
+    blockNumber?: number | undefined;
+    confirmedAt?: string | undefined;
+    receiptId?: string | undefined;
+}>;
+/**
+ * Parse execute result
+ */
+declare function parseExecuteResult(result: unknown): {
+    quoteId: string;
+    status: "pending" | "failed" | "confirmed";
+    id: string;
+    transactionHash: string;
+    initiatedAt: string;
+    confirmations: number;
+    blockNumber?: number | undefined;
+    confirmedAt?: string | undefined;
+    receiptId?: string | undefined;
+};
+
+type Draft = z.infer<typeof DraftSchema>;
+type QuoteOptions = z.infer<typeof QuoteOptionsSchema>;
+/** API Quote response schema (matches HTTP contract) */
+declare const ApiQuoteResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<["pending", "deposit_confirmed", "executing", "completed", "expired", "failed"]>;
+    recipientCount: z.ZodNumber;
+    totalAmount: z.ZodString;
+    protocolFee: z.ZodString;
+    depositAmount: z.ZodString;
+    depositAddress: z.ZodString;
+    depositChainId: z.ZodNumber;
+    depositTokenAddress: z.ZodString;
+    expiresAt: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "deposit_confirmed" | "executing" | "completed" | "expired" | "failed";
+    id: string;
+    recipientCount: number;
+    totalAmount: string;
+    protocolFee: string;
+    depositAmount: string;
+    depositAddress: string;
+    depositChainId: number;
+    depositTokenAddress: string;
+    expiresAt: string;
+    input: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}, {
+    status: "pending" | "deposit_confirmed" | "executing" | "completed" | "expired" | "failed";
+    id: string;
+    recipientCount: number;
+    totalAmount: string;
+    protocolFee: string;
+    depositAmount: string;
+    depositAddress: string;
+    depositChainId: number;
+    depositTokenAddress: string;
+    expiresAt: string;
+    input: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}>;
+type ApiQuoteResponse = z.infer<typeof ApiQuoteResponseSchema>;
+type QuoteStatus$1 = 'pending' | 'deposit_confirmed' | 'executing' | 'completed' | 'expired' | 'failed';
+/** Create a quote for a draft */
+declare function createQuote(httpClient: HttpClient, draft: Draft, opts?: Partial<QuoteOptions>): Promise<ApiQuoteResponse>;
+/** Get an existing quote by ID */
+declare function getQuote(httpClient: HttpClient, quoteId: string): Promise<ApiQuoteResponse>;
+/** Check if a quote has expired */
+declare function isQuoteExpired(quote: ApiQuoteResponse): boolean;
+/** Check if a quote is ready for deposit confirmation */
+declare function isReadyForDeposit(quote: ApiQuoteResponse): boolean;
+
+/**
+ * Confirm deposit response schema (matches HTTP contract)
+ */
+declare const ConfirmDepositResponseSchema: z.ZodObject<{
+    quoteId: z.ZodString;
+    status: z.ZodEnum<["confirmed", "pending_verification"]>;
+    detectedAmount: z.ZodString;
+    sufficient: z.ZodBoolean;
+    blockNumber: z.ZodNumber;
+    confirmedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    quoteId: string;
+    status: "confirmed" | "pending_verification";
+    detectedAmount: string;
+    sufficient: boolean;
+    blockNumber: number;
+    confirmedAt: string;
+}, {
+    quoteId: string;
+    status: "confirmed" | "pending_verification";
+    detectedAmount: string;
+    sufficient: boolean;
+    blockNumber: number;
+    confirmedAt: string;
+}>;
+type ConfirmDepositResponse = z.infer<typeof ConfirmDepositResponseSchema>;
+/**
+ * Parameters for confirming a deposit
+ */
+interface ConfirmDepositParams {
+    /** Transaction hash of the deposit (0x + 64 hex chars) */
+    txHash: string;
+    /** Unique idempotency key for safe retries */
+    idempotencyKey: string;
+}
+/**
+ * Confirm that a deposit has been made for a quote
+ *
+ * @param httpClient - The HTTP client instance
+ * @param quoteId - The quote ID to confirm deposit for
+ * @param params - Deposit confirmation parameters
+ * @returns The confirmation result
+ * @throws BeeperError if validation fails or API returns error
+ */
+declare function confirmDeposit(httpClient: HttpClient, quoteId: string, params: ConfirmDepositParams): Promise<ConfirmDepositResponse>;
+/**
+ * Check if a deposit confirmation was successful
+ */
+declare function isDepositSufficient(result: ConfirmDepositResponse): boolean;
+/**
+ * Generate a recommended idempotency key for deposit confirmation
+ */
+declare function generateDepositIdempotencyKey(quoteId: string): string;
+
+/**
+ * Execute response schema (matches HTTP contract)
+ */
+declare const ExecuteSendResponseSchema: z.ZodObject<{
+    quoteId: z.ZodString;
+    status: z.ZodEnum<["executing", "queued"]>;
+    estimatedCompletionAt: z.ZodString;
+    batchId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    quoteId: string;
+    status: "executing" | "queued";
+    estimatedCompletionAt: string;
+    batchId: string;
+}, {
+    quoteId: string;
+    status: "executing" | "queued";
+    estimatedCompletionAt: string;
+    batchId: string;
+}>;
+type ExecuteSendResponse = z.infer<typeof ExecuteSendResponseSchema>;
+/**
+ * Parameters for executing a send
+ */
+interface ExecuteSendParams {
+    /** Unique idempotency key for safe retries */
+    idempotencyKey: string;
+}
+/**
+ * Trigger execution of a send operation
+ *
+ * @param httpClient - The HTTP client instance
+ * @param quoteId - The quote ID to execute
+ * @param params - Execution parameters
+ * @returns The execution result
+ * @throws BeeperError if validation fails or API returns error
+ */
+declare function executeSend(httpClient: HttpClient, quoteId: string, params: ExecuteSendParams): Promise<ExecuteSendResponse>;
+/**
+ * Check if execution is in progress
+ */
+declare function isExecuting(result: ExecuteSendResponse): boolean;
+/**
+ * Get estimated time remaining for execution
+ */
+declare function getEstimatedTimeRemaining(result: ExecuteSendResponse): number;
+/**
+ * Generate a recommended idempotency key for execution
+ */
+declare function generateExecuteIdempotencyKey(quoteId: string): string;
+
+/** Receipt transaction schema */
+declare const ReceiptTransactionSchema: z.ZodObject<{
+    recipient: z.ZodString;
+    amount: z.ZodString;
+    txHash: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<["success", "failed"]>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    status: "failed" | "success";
+    recipient: string;
+    amount: string;
+    txHash: string | null;
+    error?: string | null | undefined;
+}, {
+    status: "failed" | "success";
+    recipient: string;
+    amount: string;
+    txHash: string | null;
+    error?: string | null | undefined;
+}>;
+/** API Receipt response schema (matches HTTP contract) */
+declare const ApiReceiptResponseSchema: z.ZodObject<{
+    quoteId: z.ZodString;
+    status: z.ZodEnum<["completed", "partial", "failed"]>;
+    successCount: z.ZodNumber;
+    failureCount: z.ZodNumber;
+    totalSent: z.ZodString;
+    refundAmount: z.ZodString;
+    refundTxHash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    transactions: z.ZodArray<z.ZodObject<{
+        recipient: z.ZodString;
+        amount: z.ZodString;
+        txHash: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<["success", "failed"]>;
+        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        txHash: string | null;
+        error?: string | null | undefined;
+    }, {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        txHash: string | null;
+        error?: string | null | undefined;
+    }>, "many">;
+    completedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    quoteId: string;
+    status: "completed" | "failed" | "partial";
+    successCount: number;
+    failureCount: number;
+    totalSent: string;
+    refundAmount: string;
+    transactions: {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        txHash: string | null;
+        error?: string | null | undefined;
+    }[];
+    completedAt: string;
+    refundTxHash?: string | null | undefined;
+}, {
+    quoteId: string;
+    status: "completed" | "failed" | "partial";
+    successCount: number;
+    failureCount: number;
+    totalSent: string;
+    refundAmount: string;
+    transactions: {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        txHash: string | null;
+        error?: string | null | undefined;
+    }[];
+    completedAt: string;
+    refundTxHash?: string | null | undefined;
+}>;
+type ApiReceiptResponse = z.infer<typeof ApiReceiptResponseSchema>;
+type ReceiptTransaction = z.infer<typeof ReceiptTransactionSchema>;
+type ReceiptStatus = 'completed' | 'partial' | 'failed';
+/** Options for polling */
+interface PollOptions {
+    maxAttempts?: number;
+    intervalMs?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Get the receipt for a quote
+ */
+declare function getReceipt(httpClient: HttpClient, quoteId: string): Promise<ApiReceiptResponse>;
+/**
+ * Poll until the execution is complete
+ */
+declare function pollUntilComplete(httpClient: HttpClient, quoteId: string, opts?: PollOptions): Promise<ApiReceiptResponse>;
+/** Check if a receipt indicates completion */
+declare function isComplete(receipt: ApiReceiptResponse): boolean;
+/** Check if execution was fully successful */
+declare function isSuccess(receipt: ApiReceiptResponse): boolean;
+/** Get the success rate as a percentage */
+declare function getSuccessRate(receipt: ApiReceiptResponse): number;
+/** Get failed transactions from a receipt */
+declare function getFailedTransactions(receipt: ApiReceiptResponse): ReceiptTransaction[];
+
+/**
+ * Authentication utilities for the Beeper SDK
+ */
+/**
+ * API key prefix patterns
+ */
+declare const API_KEY_PREFIXES: {
+    readonly LIVE: "bpk_live_";
+    readonly TEST: "bpk_test_";
+};
+/**
+ * Validates that an API key has the correct format
+ * @param apiKey - The API key to validate
+ * @returns true if the key format is valid
+ */
+declare function isValidApiKeyFormat(apiKey: string): boolean;
+/**
+ * Determines if an API key is for production or test environment
+ * @param apiKey - The API key to check
+ * @returns 'production' | 'test' | null if invalid
+ */
+declare function getApiKeyEnvironment(apiKey: string): 'production' | 'test' | null;
+/**
+ * Creates the Authorization header value
+ * @param apiKey - The API key
+ * @returns The Bearer token string
+ */
+declare function createAuthorizationHeader(apiKey: string): string;
+/**
+ * Masks an API key for safe logging
+ * @param apiKey - The API key to mask
+ * @returns Masked key showing only prefix and last 4 characters
+ */
+declare function maskApiKey(apiKey: string): string;
+
+/**
+ * Core types for the Beeper SDK
+ *
+ * Matches the beep.works server API at /api/v1/sdk/*
+ */
+/**
+ * Supported blockchain chains for wallet filters
+ */
+type WalletChain$1 = 'ethereum' | 'base' | 'arbitrum' | 'polygon' | 'optimism';
+/**
+ * Supported platforms for targeting
+ */
+type Platform$1 = 'all' | 'farcaster' | 'twitter';
+/**
+ * Token standard for token holder filters
+ */
+type TokenStandard = 'ERC20' | 'ERC721' | 'ERC1155';
+/**
+ * Sort order options
+ */
+type OrderBy$1 = 'attention_price_asc' | 'attention_price_desc' | 'neynar_score_desc' | 'followers_desc' | 'followers_asc' | 'recent_activity' | 'battery_desc' | 'random';
+/**
+ * Spam label options
+ */
+type SpamLabel = 'not_spam_only' | 'spam_only' | 'all';
+/**
+ * Token holder filter config
+ */
+interface TokenHolderConfig {
+    chain: 'base' | 'ethereum';
+    contractAddress: string;
+    tokenStandard: TokenStandard;
+    tokenId?: string;
+    minBalance?: string | number;
+}
+/**
+ * Recipient Filter DSL
+ * Supports complex logical expressions for targeting users
+ */
+type RecipientFilter$1 = {
+    and: RecipientFilter$1[];
+} | {
+    or: RecipientFilter$1[];
+} | {
+    not: RecipientFilter$1;
+} | {
+    hasTag: string;
+} | {
+    hasAnyTag: string[];
+} | {
+    hasAllTags: string[];
+} | {
+    walletChain: WalletChain$1;
+} | {
+    walletHasToken: {
+        tokenAddress: string;
+        chainId: number;
+    };
+} | {
+    walletMinBalance: {
+        tokenAddress: string;
+        chainId: number;
+        minBalance: string;
+    };
+} | {
+    userId: string;
+} | {
+    userIds: string[];
+} | {
+    fid: number;
+} | {
+    fids: number[];
+} | {
+    createdAfter: string;
+} | {
+    createdBefore: string;
+} | {
+    lastActiveAfter: string;
+} | {
+    completedReward: string;
+} | {
+    notCompletedReward: string;
+} | {
+    completedQuest: string;
+} | {
+    hasAchievement: string;
+} | {
+    platform: Platform$1;
+} | {
+    activeInLastDays: number;
+} | {
+    neynarScoreMin: number;
+} | {
+    neynarScoreMax: number;
+} | {
+    neynarScoreRange: {
+        min?: number;
+        max?: number;
+    };
+} | {
+    minFollowers: number;
+} | {
+    maxFollowers: number;
+} | {
+    followerRange: {
+        min?: number;
+        max?: number;
+    };
+} | {
+    followersOf: number;
+} | {
+    mutualsWith: number;
+} | {
+    maxAttentionPriceUsd: number;
+} | {
+    tokenHolders: TokenHolderConfig[];
+} | {
+    cachedTokenHolders: TokenHolderConfig[];
+} | {
+    spamLabel: SpamLabel;
+} | {
+    signalTokens: string[];
+} | {
+    hasBaseWallet: boolean;
+} | {
+    hasVerifiedWallet: boolean;
+} | {
+    verifiedOnly: boolean;
+} | {
+    proSubscriptionRequired: boolean;
+} | {
+    minTenureDays: number;
+} | {
+    timezones: Array<{
+        offset: number;
+        range?: number;
+    }>;
+} | {
+    countries: Array<{
+        code: string;
+    }>;
+} | {
+    quotientScoreMin: number;
+} | {
+    quotientScoreMax: number;
+} | {
+    quotientScoreRange: {
+        min?: number;
+        max?: number;
+    };
+} | {
+    minBatteryPercentage: number;
+} | {
+    hasRechargedInLastDays: number;
+} | {
+    excludePingedToday: boolean;
+} | {
+    requireLotteryOptIn: boolean;
+} | {
+    requireQuizOptIn: boolean;
+} | {
+    minCastCount: number;
+} | {
+    orderBy: OrderBy$1;
+};
+/**
+ * Supported chain IDs
+ */
+type SupportedChainId = 1 | 8453 | 42161;
+/**
+ * Reward types for attention marketplace mode
+ */
+type RewardType = 'guaranteed' | 'lottery' | 'fcfs';
+/**
+ * Quote status
+ */
+type QuoteStatus = 'pending' | 'deposit_confirmed' | 'executing' | 'completed' | 'failed' | 'expired' | 'cancelled';
+/**
+ * Token distribution mode input
+ * Used for direct token airdrops
+ */
+interface TokenDistributionInput {
+    /** Recipient filter expression */
+    filter: RecipientFilter$1;
+    /** Token contract address */
+    tokenAddress: string;
+    /** Chain ID (1=Ethereum, 8453=Base, 42161=Arbitrum) */
+    chainId: SupportedChainId;
+    /** Amount per recipient in wei (as string) */
+    amountPerRecipient: string;
+    /** Maximum total budget in wei (as string) */
+    budgetCap: string;
+    /** Optional memo/note */
+    memo?: string;
+    /** Optional metadata (max 4KB JSON) */
+    metadata?: Record<string, unknown>;
+    /** TTL in seconds (60-3600, default 300) */
+    ttlSeconds?: number;
+}
+/**
+ * Attention marketplace mode input
+ * Used for sending beep messages with rewards
+ */
+interface AttentionMarketplaceInput {
+    /** Message content to send */
+    message: string;
+    /** Direct FID targeting (optional) */
+    recipientFids?: number[];
+    /** Filter expression (optional, required if no recipientFids) */
+    filter?: RecipientFilter$1;
+    /** Budget in USD */
+    budgetUSD: string;
+    /** Reward distribution type */
+    rewardType?: RewardType;
+    /** Optional memo/note */
+    memo?: string;
+    /** Optional metadata (max 4KB JSON) */
+    metadata?: Record<string, unknown>;
+    /** TTL in seconds (60-3600, default 300) */
+    ttlSeconds?: number;
+}
+/**
+ * Create quote input - either token distribution or attention marketplace
+ */
+type CreateQuoteInput = TokenDistributionInput | AttentionMarketplaceInput;
+/**
+ * Quote response from the server
+ */
+interface Quote {
+    /** Unique quote ID (prefixed with qt_) */
+    id: string;
+    /** Quote status */
+    status: QuoteStatus;
+    /** Number of recipients matched */
+    recipientCount: number;
+    /** Total amount in wei */
+    totalAmount: string;
+    /** Protocol fee in wei */
+    protocolFee: string;
+    /** Required deposit amount in wei */
+    depositAmount: string;
+    /** Address to deposit to */
+    depositAddress: string;
+    /** Chain ID for deposit */
+    depositChainId: number;
+    /** Token address for deposit */
+    depositTokenAddress: string;
+    /** When the quote expires */
+    expiresAt: string;
+    /** Original input parameters */
+    input: TokenDistributionInput | AttentionMarketplaceInput;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+/**
+ * Deposit confirmation request
+ */
+interface ConfirmDepositInput {
+    /** Transaction hash of the deposit */
+    txHash: string;
+}
+/**
+ * Deposit confirmation response
+ */
+interface ConfirmDepositResult {
+    /** Quote ID */
+    quoteId: string;
+    /** New status (should be 'confirmed') */
+    status: 'confirmed' | 'insufficient';
+    /** Detected deposit amount */
+    detectedAmount: string;
+    /** Whether the deposit is sufficient */
+    sufficient: boolean;
+    /** When deposit was confirmed */
+    confirmedAt: string;
+}
+/**
+ * Execution response
+ */
+interface ExecuteResult {
+    /** Quote ID */
+    quoteId: string;
+    /** Execution status */
+    status: 'executing' | 'completed' | 'failed';
+    /** Estimated completion time */
+    estimatedCompletionAt?: string;
+    /** Batch ID for tracking */
+    batchId?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Receipt for a completed distribution
+ */
+interface Receipt {
+    /** Receipt ID */
+    id: string;
+    /** Quote ID */
+    quoteId: string;
+    /** Final status */
+    status: 'completed' | 'partial' | 'failed';
+    /** Total amount distributed */
+    totalDistributed: string;
+    /** Number of successful transfers */
+    successfulTransfers: number;
+    /** Number of failed transfers */
+    failedTransfers: number;
+    /** Transaction hashes */
+    transactionHashes: string[];
+    /** Completion timestamp */
+    completedAt: string;
+}
+/**
+ * API Key creation input
+ */
+interface CreateApiKeyInput {
+    /** Human-readable name */
+    name: string;
+    /** Optional expiration date */
+    expiresAt?: string;
+}
+/**
+ * API Key response
+ */
+interface ApiKey {
+    /** Key ID */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** The actual key (only returned on creation) */
+    key?: string;
+    /** Masked version of the key */
+    maskedKey: string;
+    /** Whether the key is active */
+    isActive: boolean;
+    /** When the key expires (if set) */
+    expiresAt?: string;
+    /** Last time the key was used */
+    lastUsedAt?: string;
+    /** Usage count */
+    usageCount: number;
+    /** Creation timestamp */
+    createdAt: string;
+}
+/**
+ * SDK Configuration options
+ */
+interface BeeperConfig {
+    /** API key for authentication (Bearer token) */
+    apiKey: string;
+    /** Environment to use */
+    environment?: 'production' | 'staging' | 'development';
+    /** Custom base URL (overrides environment) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof fetch;
+    /** Maximum retries for failed requests */
+    maxRetries?: number;
+}
+/**
+ * Health check response
+ */
+interface Health {
+    /** Service status */
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    /** Service version */
+    version: string;
+    /** Timestamp of check */
+    timestamp: string;
+    /** Status of individual services */
+    services: {
+        database: 'up' | 'down';
+        queue: 'up' | 'down';
+        oracle: 'up' | 'down';
+    };
+}
+/**
+ * API Error response structure
+ */
+interface ApiError {
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+
+/**
+ * FilterBuilder - Fluent API for building SDK filter expressions
+ *
+ * Used to construct filter objects for the /api/v1/sdk/send/quotes endpoint.
+ * Supports logical combinators (and, or, not) and various filter types.
+ *
+ * @example
+ * ```typescript
+ * import { FilterBuilder } from '@beeper/sdk';
+ *
+ * const filter = FilterBuilder.and([
+ *   FilterBuilder.platform('farcaster'),
+ *   FilterBuilder.activeInLastDays(30),
+ *   FilterBuilder.neynarScoreMin(0.5),
+ *   FilterBuilder.or([
+ *     FilterBuilder.minFollowers(1000),
+ *     FilterBuilder.followersOf(12345),
+ *   ]),
+ * ]);
+ *
+ * // Use in API request
+ * const draft = client.createDraft({
+ *   filter: filter.toJSON(),
+ *   // ... other params
+ * });
+ * ```
+ */
+/** Supported blockchain chains */
+type WalletChain = 'ethereum' | 'base' | 'arbitrum' | 'polygon' | 'optimism';
+/** Supported platforms */
+type Platform = 'all' | 'farcaster' | 'twitter';
+/** Extended spam label for spamLabel filter */
+type SpamLabelOption = 'not_spam_only' | 'spam_only' | 'all';
+/** Timezone filter options */
+interface TimezoneOptions {
+    /** UTC offset in hours (e.g., -5 for EST, 9 for JST) */
+    offset: number;
+    /** Range in hours (optional, for fuzzy matching) */
+    range?: number;
+}
+/** Order by options for result sorting */
+type OrderByOption = 'attention_price_asc' | 'attention_price_desc' | 'neynar_score_desc' | 'followers_desc' | 'followers_asc' | 'recent_activity' | 'battery_desc' | 'random';
+/** Token holder filter options */
+interface TokenHolderOptions {
+    /** Token contract address (0x prefixed) */
+    tokenAddress: string;
+    /** Chain ID (1 = Ethereum, 8453 = Base, 42161 = Arbitrum) */
+    chainId: number;
+    /** Minimum balance in wei (optional) */
+    minBalance?: string;
+}
+/** Base filter expression that all filters extend */
+type FilterExpressionJSON = {
+    and: FilterExpressionJSON[];
+} | {
+    or: FilterExpressionJSON[];
+} | {
+    not: FilterExpressionJSON;
+} | {
+    hasTag: string;
+} | {
+    hasAnyTag: string[];
+} | {
+    hasAllTags: string[];
+} | {
+    walletChain: WalletChain;
+} | {
+    walletHasToken: {
+        tokenAddress: string;
+        chainId: number;
+    };
+} | {
+    walletMinBalance: {
+        tokenAddress: string;
+        chainId: number;
+        minBalance: string;
+    };
+} | {
+    userId: string;
+} | {
+    userIds: string[];
+} | {
+    fid: number;
+} | {
+    fids: number[];
+} | {
+    createdAfter: string;
+} | {
+    createdBefore: string;
+} | {
+    lastActiveAfter: string;
+} | {
+    completedReward: string;
+} | {
+    notCompletedReward: string;
+} | {
+    completedQuest: string;
+} | {
+    hasAchievement: string;
+} | {
+    platform: Platform;
+} | {
+    activeInLastDays: number;
+} | {
+    neynarScoreMin: number;
+} | {
+    neynarScoreMax: number;
+} | {
+    neynarScoreRange: {
+        min?: number;
+        max?: number;
+    };
+} | {
+    minFollowers: number;
+} | {
+    maxFollowers: number;
+} | {
+    followerRange: {
+        min?: number;
+        max?: number;
+    };
+} | {
+    followersOf: number;
+} | {
+    mutualsWith: number;
+} | {
+    maxAttentionPriceUsd: number;
+} | {
+    tokenHolders: Array<{
+        tokenAddress: string;
+        chainId: number;
+        minBalance?: string;
+    }>;
+} | {
+    cachedTokenHolders: Array<{
+        tokenAddress: string;
+        chainId: number;
+        minBalance?: string;
+    }>;
+} | {
+    spamLabel: SpamLabelOption;
+} | {
+    signalTokens: string[];
+} | {
+    hasBaseWallet: boolean;
+} | {
+    hasVerifiedWallet: boolean;
+} | {
+    verifiedOnly: boolean;
+} | {
+    proSubscriptionRequired: boolean;
+} | {
+    minTenureDays: number;
+} | {
+    timezones: Array<{
+        offset: number;
+        range?: number;
+    }>;
+} | {
+    countries: Array<{
+        code: string;
+    }>;
+} | {
+    quotientScoreMin: number;
+} | {
+    quotientScoreMax: number;
+} | {
+    quotientScoreRange: {
+        min?: number;
+        max?: number;
+    };
+} | {
+    minBatteryPercentage: number;
+} | {
+    hasRechargedInLastDays: number;
+} | {
+    excludePingedToday: boolean;
+} | {
+    requireLotteryOptIn: boolean;
+} | {
+    requireQuizOptIn: boolean;
+} | {
+    minCastCount: number;
+} | {
+    orderBy: OrderByOption;
+} | {
+    limit: number;
+};
+/**
+ * FilterExpression class - wraps a filter JSON object with builder methods
+ */
+declare class FilterExpression$1 {
+    private readonly expression;
+    constructor(expression: FilterExpressionJSON);
+    /**
+     * Convert the filter expression to JSON format for API requests
+     */
+    toJSON(): FilterExpressionJSON;
+    /**
+     * Combine this filter with another using AND logic
+     */
+    and(other: FilterExpression$1): FilterExpression$1;
+    /**
+     * Combine this filter with another using OR logic
+     */
+    or(other: FilterExpression$1): FilterExpression$1;
+    /**
+     * Negate this filter
+     */
+    not(): FilterExpression$1;
+}
+/**
+ * FilterBuilder - Static factory methods for creating filter expressions
+ *
+ * All methods return FilterExpression objects that can be combined
+ * using and(), or(), and not() methods.
+ */
+declare class FilterBuilder {
+    /**
+     * Combine multiple filters with AND logic (all must match)
+     * @param filters - Array of filter expressions to combine
+     */
+    static and(filters: FilterExpression$1[]): FilterExpression$1;
+    /**
+     * Combine multiple filters with OR logic (any must match)
+     * @param filters - Array of filter expressions to combine
+     */
+    static or(filters: FilterExpression$1[]): FilterExpression$1;
+    /**
+     * Negate a filter (matches users who do NOT match the filter)
+     * @param filter - Filter expression to negate
+     */
+    static not(filter: FilterExpression$1): FilterExpression$1;
+    /**
+     * Filter by platform
+     * @param p - Platform to target: 'all', 'farcaster', or 'twitter'
+     */
+    static platform(p: Platform): FilterExpression$1;
+    /**
+     * Filter users who have been active within the last N days
+     * @param days - Number of days (1-365)
+     */
+    static activeInLastDays(days: number): FilterExpression$1;
+    /**
+     * Filter users with Neynar score >= minimum
+     * @param score - Minimum score (0-1)
+     */
+    static neynarScoreMin(score: number): FilterExpression$1;
+    /**
+     * Filter users with Neynar score <= maximum
+     * @param score - Maximum score (0-1)
+     */
+    static neynarScoreMax(score: number): FilterExpression$1;
+    /**
+     * Filter users with Neynar score in a range
+     * @param min - Minimum score (0-1, optional)
+     * @param max - Maximum score (0-1, optional)
+     */
+    static neynarScoreRange(min?: number, max?: number): FilterExpression$1;
+    /**
+     * Filter by spam label
+     * @param label - Spam label filter: 'not_spam_only', 'spam_only', or 'all'
+     */
+    static spamLabel(label: SpamLabelOption): FilterExpression$1;
+    /**
+     * Filter to exclude spam users (convenience method)
+     * @deprecated Use spamLabel('not_spam_only') instead
+     */
+    static excludeSpam(): FilterExpression$1;
+    /**
+     * Filter users with at least N followers
+     * @param count - Minimum follower count
+     */
+    static minFollowers(count: number): FilterExpression$1;
+    /**
+     * Filter users with at most N followers
+     * @param count - Maximum follower count
+     */
+    static maxFollowers(count: number): FilterExpression$1;
+    /**
+     * Filter users with follower count in a range
+     * @param min - Minimum follower count (optional)
+     * @param max - Maximum follower count (optional)
+     */
+    static followerRange(min?: number, max?: number): FilterExpression$1;
+    /**
+     * Filter users who follow a specific FID
+     * @param fid - Farcaster ID to check followers of
+     */
+    static followersOf(fid: number): FilterExpression$1;
+    /**
+     * Filter users who have mutual follows with a specific FID
+     * @param fid - Farcaster ID to check mutual follows with
+     */
+    static mutualsWith(fid: number): FilterExpression$1;
+    /**
+     * Filter users with attention price <= maximum USD
+     * @param usd - Maximum attention price in USD
+     */
+    static maxAttentionPriceUsd(usd: number): FilterExpression$1;
+    /**
+     * Filter users who hold a specific token
+     * @param opts - Token holder options (tokenAddress, chainId, optional minBalance)
+     */
+    static tokenHolder(opts: TokenHolderOptions): FilterExpression$1;
+    /**
+     * Filter users who hold any of the specified tokens (multiple token filter)
+     * @param opts - Array of token holder options (max 10)
+     */
+    static tokenHolders(opts: TokenHolderOptions[]): FilterExpression$1;
+    /**
+     * Filter users who hold any of the specified tokens (uses pre-synced cache for faster queries)
+     * @param opts - Array of token holder options (max 10)
+     */
+    static cachedTokenHolders(opts: TokenHolderOptions[]): FilterExpression$1;
+    /**
+     * Filter users who have configured specific signal tokens
+     * @param tokenAddresses - Array of token contract addresses (max 20)
+     */
+    static signalTokens(tokenAddresses: string[]): FilterExpression$1;
+    /**
+     * Filter users with a wallet on a specific chain
+     * @param chain - Blockchain chain
+     */
+    static walletChain(chain: WalletChain): FilterExpression$1;
+    /**
+     * Filter users who have a Base chain wallet
+     */
+    static hasBaseWallet(): FilterExpression$1;
+    /**
+     * Filter users who have a verified wallet
+     */
+    static hasVerifiedWallet(): FilterExpression$1;
+    /**
+     * Filter to only verified users
+     */
+    static verifiedOnly(): FilterExpression$1;
+    /**
+     * Filter to only users with Pro subscription
+     */
+    static proSubscriptionRequired(): FilterExpression$1;
+    /**
+     * Filter users with minimum account tenure
+     * @param days - Minimum number of days since account creation
+     */
+    static minTenureDays(days: number): FilterExpression$1;
+    /**
+     * Filter by specific user ID
+     * @param id - User ID
+     */
+    static userId(id: string): FilterExpression$1;
+    /**
+     * Filter by multiple user IDs
+     * @param ids - Array of user IDs (max 1000)
+     */
+    static userIds(ids: string[]): FilterExpression$1;
+    /**
+     * Filter by specific Farcaster ID
+     * @param fid - Farcaster ID
+     */
+    static fid(fid: number): FilterExpression$1;
+    /**
+     * Filter by multiple Farcaster IDs
+     * @param fids - Array of Farcaster IDs (max 1000)
+     */
+    static fids(fids: number[]): FilterExpression$1;
+    /**
+     * Filter users with a specific tag
+     * @param tag - Tag name (max 64 chars)
+     */
+    static hasTag(tag: string): FilterExpression$1;
+    /**
+     * Filter users with any of the specified tags
+     * @param tags - Array of tag names (1-20 tags)
+     */
+    static hasAnyTag(tags: string[]): FilterExpression$1;
+    /**
+     * Filter users with all of the specified tags
+     * @param tags - Array of tag names (1-20 tags)
+     */
+    static hasAllTags(tags: string[]): FilterExpression$1;
+    /**
+     * Filter users created after a specific date
+     * @param date - Date or ISO 8601 string
+     */
+    static createdAfter(date: Date | string): FilterExpression$1;
+    /**
+     * Filter users created before a specific date
+     * @param date - Date or ISO 8601 string
+     */
+    static createdBefore(date: Date | string): FilterExpression$1;
+    /**
+     * Filter users who were last active after a specific date
+     * @param date - Date or ISO 8601 string
+     */
+    static lastActiveAfter(date: Date | string): FilterExpression$1;
+    /**
+     * Filter users who completed a specific reward
+     * @param rewardId - Reward ID
+     */
+    static completedReward(rewardId: string): FilterExpression$1;
+    /**
+     * Filter users who have NOT completed a specific reward
+     * @param rewardId - Reward ID
+     */
+    static notCompletedReward(rewardId: string): FilterExpression$1;
+    /**
+     * Filter users who completed a specific quest
+     * @param questId - Quest ID
+     */
+    static completedQuest(questId: string): FilterExpression$1;
+    /**
+     * Filter users who have a specific achievement
+     * @param achievementId - Achievement ID
+     */
+    static hasAchievement(achievementId: string): FilterExpression$1;
+    /**
+     * Filter users by timezone
+     * @param zones - Array of timezone options with UTC offset and optional range (max 24)
+     */
+    static timezones(zones: TimezoneOptions[]): FilterExpression$1;
+    /**
+     * Filter users by country (ISO 3166-1 alpha-2 codes)
+     * @param codes - Array of ISO 3166-1 alpha-2 country codes (e.g., ['US', 'CA', 'GB'])
+     */
+    static countries(codes: string[]): FilterExpression$1;
+    /**
+     * Filter users with quotient score >= minimum
+     * @param score - Minimum quotient score (0-1, where 0.5=Casual, 0.75=Influential, 0.9=Exceptional)
+     */
+    static quotientScoreMin(score: number): FilterExpression$1;
+    /**
+     * Filter users with quotient score <= maximum
+     * @param score - Maximum quotient score (0-1)
+     */
+    static quotientScoreMax(score: number): FilterExpression$1;
+    /**
+     * Filter users with quotient score in a range
+     * @param min - Minimum score (0-1, optional)
+     * @param max - Maximum score (0-1, optional)
+     */
+    static quotientScoreRange(min?: number, max?: number): FilterExpression$1;
+    /**
+     * Filter users with minimum battery percentage
+     * @param pct - Minimum battery percentage (0-100)
+     */
+    static minBatteryPercentage(pct: number): FilterExpression$1;
+    /**
+     * Filter users who have recharged their battery within the last N days
+     * @param days - Number of days
+     */
+    static hasRechargedInLastDays(days: number): FilterExpression$1;
+    /**
+     * Exclude users who have already been pinged today
+     */
+    static excludePingedToday(): FilterExpression$1;
+    /**
+     * Filter to only users who have opted into lottery rewards
+     */
+    static requireLotteryOptIn(): FilterExpression$1;
+    /**
+     * Filter to only users who have opted into quiz rewards
+     */
+    static requireQuizOptIn(): FilterExpression$1;
+    /**
+     * Filter users with minimum cast count
+     * @param count - Minimum number of casts
+     */
+    static minCastCount(count: number): FilterExpression$1;
+    /**
+     * Set the order for results
+     * @param order - Order option for sorting results
+     */
+    static orderBy(order: OrderByOption): FilterExpression$1;
+    /**
+     * Limit the number of results
+     * @param n - Maximum number of results
+     * @deprecated Limit is controlled by budgetCap, not this filter. This method will be removed.
+     */
+    static limit(n: number): FilterExpression$1;
+}
+
+/**
+ * All error codes for the Beeper SDK
+ */
+declare const ErrorCodes: {
+    readonly QUOTE_EXPIRED: "QUOTE_EXPIRED";
+    readonly QUOTE_NOT_FOUND: "QUOTE_NOT_FOUND";
+    readonly QUOTE_INVALID: "QUOTE_INVALID";
+    readonly INVALID_RECIPIENT: "INVALID_RECIPIENT";
+    readonly RECIPIENT_NOT_FOUND: "RECIPIENT_NOT_FOUND";
+    readonly INVALID_FILTER: "INVALID_FILTER";
+    readonly FILTER_SYNTAX_ERROR: "FILTER_SYNTAX_ERROR";
+    readonly BUDGET_TOO_LOW: "BUDGET_TOO_LOW";
+    readonly BUDGET_EXCEEDED: "BUDGET_EXCEEDED";
+    readonly PAYMENT_NOT_FOUND: "PAYMENT_NOT_FOUND";
+    readonly PAYMENT_INSUFFICIENT: "PAYMENT_INSUFFICIENT";
+    readonly PAYMENT_FAILED: "PAYMENT_FAILED";
+    readonly EXECUTION_ALREADY_TRIGGERED: "EXECUTION_ALREADY_TRIGGERED";
+    readonly EXECUTION_FAILED: "EXECUTION_FAILED";
+    readonly EXECUTION_PENDING: "EXECUTION_PENDING";
+    readonly RATE_LIMITED: "RATE_LIMITED";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly FORBIDDEN: "FORBIDDEN";
+    readonly API_KEY_INVALID: "API_KEY_INVALID";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly CONNECTION_REFUSED: "CONNECTION_REFUSED";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly SCHEMA_VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+    readonly DRAFT_NOT_FOUND: "DRAFT_NOT_FOUND";
+    readonly DRAFT_INVALID: "DRAFT_INVALID";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+};
+type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+/**
+ * Error codes that indicate the operation can be retried
+ */
+declare const RETRYABLE_ERROR_CODES: readonly ErrorCode[];
+/**
+ * Check if an error code is retryable
+ */
+declare function isRetryableCode(code: ErrorCode): boolean;
+/**
+ * HTTP status code to error code mapping
+ */
+declare const HTTP_STATUS_TO_ERROR_CODE: Record<number, ErrorCode>;
+
+/**
+ * Additional context that may be included with errors
+ */
+interface ErrorContext {
+    /** The request ID from the server */
+    requestId?: string | undefined;
+    /** HTTP status code if from an HTTP response */
+    statusCode?: number | undefined;
+    /** The endpoint that was called */
+    endpoint?: string | undefined;
+    /** Additional details from the API */
+    details?: Record<string, unknown> | undefined;
+    /** Retry-After header value in seconds */
+    retryAfter?: number | undefined;
+}
+/**
+ * Options for creating a BeeperError
+ */
+interface BeeperErrorOptions {
+    code: ErrorCode;
+    message: string;
+    cause?: Error | undefined;
+    context?: ErrorContext | undefined;
+    retryable?: boolean | undefined;
+}
+/**
+ * Base error class for all Beeper SDK errors
+ */
+declare class BeeperError extends Error {
+    /** Error code identifying the type of error */
+    readonly code: ErrorCode;
+    /** Whether this error can be retried */
+    readonly retryable: boolean;
+    /** Additional context about the error */
+    readonly context: ErrorContext;
+    /** The original error that caused this error */
+    readonly cause?: Error | undefined;
+    constructor(options: BeeperErrorOptions);
+    /**
+     * Create a string representation of the error
+     */
+    toString(): string;
+    /**
+     * Convert to a plain object for logging/serialization
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Create a network error
+     */
+    static networkError(message: string, cause?: Error | undefined): BeeperError;
+    /**
+     * Create a timeout error
+     */
+    static timeout(endpoint: string, timeoutMs: number): BeeperError;
+    /**
+     * Create an unauthorized error
+     */
+    static unauthorized(message?: string): BeeperError;
+    /**
+     * Create a rate limited error
+     */
+    static rateLimited(retryAfter?: number | undefined): BeeperError;
+    /**
+     * Create a validation error
+     */
+    static validation(message: string, details?: Record<string, unknown> | undefined): BeeperError;
+    /**
+     * Create a quote expired error
+     */
+    static quoteExpired(quoteId: string): BeeperError;
+    /**
+     * Create from an HTTP response
+     */
+    static fromHttpResponse(statusCode: number, body: unknown, requestId?: string | undefined): BeeperError;
+}
+
+/**
+ * Transfer status
+ */
+declare const TransferStatusSchema: z.ZodEnum<["success", "failed"]>;
+/**
+ * Receipt transfer schema
+ */
+declare const ReceiptTransferSchema: z.ZodObject<{
+    recipient: z.ZodString;
+    amount: z.ZodString;
+    status: z.ZodEnum<["success", "failed"]>;
+    logIndex: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "failed" | "success";
+    recipient: string;
+    amount: string;
+    logIndex: number;
+}, {
+    status: "failed" | "success";
+    recipient: string;
+    amount: string;
+    logIndex: number;
+}>;
+/**
+ * Receipt schema
+ */
+declare const ReceiptSchema: z.ZodObject<{
+    id: z.ZodString;
+    executionId: z.ZodString;
+    quoteId: z.ZodString;
+    draftId: z.ZodString;
+    transactionHash: z.ZodString;
+    blockNumber: z.ZodNumber;
+    blockTimestamp: z.ZodString;
+    network: z.ZodEnum<["ethereum", "polygon", "base", "arbitrum", "optimism"]>;
+    token: z.ZodEnum<["USDC", "USDT", "ETH", "MATIC"]>;
+    totalAmount: z.ZodString;
+    gasUsed: z.ZodString;
+    gasPrice: z.ZodString;
+    gasCost: z.ZodString;
+    transfers: z.ZodArray<z.ZodObject<{
+        recipient: z.ZodString;
+        amount: z.ZodString;
+        status: z.ZodEnum<["success", "failed"]>;
+        logIndex: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        logIndex: number;
+    }, {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        logIndex: number;
+    }>, "many">;
+    successfulTransfers: z.ZodNumber;
+    failedTransfers: z.ZodNumber;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    quoteId: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    id: string;
+    totalAmount: string;
+    createdAt: string;
+    blockNumber: number;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    draftId: string;
+    gasPrice: string;
+    transactionHash: string;
+    executionId: string;
+    blockTimestamp: string;
+    gasUsed: string;
+    gasCost: string;
+    transfers: {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        logIndex: number;
+    }[];
+    successfulTransfers: number;
+    failedTransfers: number;
+}, {
+    quoteId: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    id: string;
+    totalAmount: string;
+    createdAt: string;
+    blockNumber: number;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    draftId: string;
+    gasPrice: string;
+    transactionHash: string;
+    executionId: string;
+    blockTimestamp: string;
+    gasUsed: string;
+    gasCost: string;
+    transfers: {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        logIndex: number;
+    }[];
+    successfulTransfers: number;
+    failedTransfers: number;
+}>;
+/**
+ * Validate receipt response
+ */
+declare function validateReceipt(receipt: unknown): z.SafeParseReturnType<{
+    quoteId: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    id: string;
+    totalAmount: string;
+    createdAt: string;
+    blockNumber: number;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    draftId: string;
+    gasPrice: string;
+    transactionHash: string;
+    executionId: string;
+    blockTimestamp: string;
+    gasUsed: string;
+    gasCost: string;
+    transfers: {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        logIndex: number;
+    }[];
+    successfulTransfers: number;
+    failedTransfers: number;
+}, {
+    quoteId: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    id: string;
+    totalAmount: string;
+    createdAt: string;
+    blockNumber: number;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    draftId: string;
+    gasPrice: string;
+    transactionHash: string;
+    executionId: string;
+    blockTimestamp: string;
+    gasUsed: string;
+    gasCost: string;
+    transfers: {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        logIndex: number;
+    }[];
+    successfulTransfers: number;
+    failedTransfers: number;
+}>;
+/**
+ * Parse receipt response
+ */
+declare function parseReceipt(receipt: unknown): {
+    quoteId: string;
+    network: "base" | "ethereum" | "polygon" | "arbitrum" | "optimism";
+    id: string;
+    totalAmount: string;
+    createdAt: string;
+    blockNumber: number;
+    token: "USDC" | "USDT" | "ETH" | "MATIC";
+    draftId: string;
+    gasPrice: string;
+    transactionHash: string;
+    executionId: string;
+    blockTimestamp: string;
+    gasUsed: string;
+    gasCost: string;
+    transfers: {
+        status: "failed" | "success";
+        recipient: string;
+        amount: string;
+        logIndex: number;
+    }[];
+    successfulTransfers: number;
+    failedTransfers: number;
+};
+
+/**
+ * @deprecated Use the new DSL filter schemas instead
+ * Filter operators schema (legacy)
+ */
+declare const LegacyFilterOperatorSchema: z.ZodEnum<["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "contains", "startsWith", "endsWith"]>;
+/**
+ * @deprecated Use the new DSL filter schemas instead
+ * Filter value schema - supports primitives and arrays (legacy)
+ */
+declare const LegacyFilterValueSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
+/**
+ * @deprecated Use the new DSL filter schemas instead
+ * Field comparison schema (legacy)
+ */
+declare const LegacyFieldComparisonSchema: z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "contains", "startsWith", "endsWith"]>;
+    value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
+}, "strip", z.ZodTypeAny, {
+    value: string | number | boolean | number[] | string[];
+    field: string;
+    op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "contains" | "startsWith" | "endsWith";
+}, {
+    value: string | number | boolean | number[] | string[];
+    field: string;
+    op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "contains" | "startsWith" | "endsWith";
+}>;
+/**
+ * @deprecated Use RecipientFilterSchema instead
+ * Recursive filter DSL schema (legacy)
+ */
+declare const LegacyRecipientFilterDSLSchema: z.ZodType<unknown>;
+declare const FilterOperatorSchema: z.ZodEnum<["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "contains", "startsWith", "endsWith"]>;
+declare const FilterValueSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
+declare const FieldComparisonSchema: z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "contains", "startsWith", "endsWith"]>;
+    value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
+}, "strip", z.ZodTypeAny, {
+    value: string | number | boolean | number[] | string[];
+    field: string;
+    op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "contains" | "startsWith" | "endsWith";
+}, {
+    value: string | number | boolean | number[] | string[];
+    field: string;
+    op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "contains" | "startsWith" | "endsWith";
+}>;
+declare const PlatformFilterSchema: z.ZodObject<{
+    platform: z.ZodEnum<["all", "farcaster", "twitter"]>;
+}, "strip", z.ZodTypeAny, {
+    platform: "all" | "farcaster" | "twitter";
+}, {
+    platform: "all" | "farcaster" | "twitter";
+}>;
+declare const SpecificUsersFilterSchema: z.ZodObject<{
+    specificIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    specificFids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    specificUsernames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    specificUsersMode: z.ZodOptional<z.ZodEnum<["exclusive", "additive"]>>;
+}, "strip", z.ZodTypeAny, {
+    specificIds?: string[] | undefined;
+    specificFids?: number[] | undefined;
+    specificUsernames?: string[] | undefined;
+    specificUsersMode?: "exclusive" | "additive" | undefined;
+}, {
+    specificIds?: string[] | undefined;
+    specificFids?: number[] | undefined;
+    specificUsernames?: string[] | undefined;
+    specificUsersMode?: "exclusive" | "additive" | undefined;
+}>;
+declare const ExcludeUsersFilterSchema: z.ZodObject<{
+    excludeFids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    excludeUsernames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    excludeFids?: number[] | undefined;
+    excludeUsernames?: string[] | undefined;
+}, {
+    excludeFids?: number[] | undefined;
+    excludeUsernames?: string[] | undefined;
+}>;
+declare const MinFollowersFilterSchema: z.ZodObject<{
+    minFollowers: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    minFollowers: number;
+}, {
+    minFollowers: number;
+}>;
+declare const MaxFollowersFilterSchema: z.ZodObject<{
+    maxFollowers: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    maxFollowers: number;
+}, {
+    maxFollowers: number;
+}>;
+declare const MinFollowingFilterSchema: z.ZodObject<{
+    minFollowing: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    minFollowing: number;
+}, {
+    minFollowing: number;
+}>;
+declare const MaxFollowingFilterSchema: z.ZodObject<{
+    maxFollowing: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    maxFollowing: number;
+}, {
+    maxFollowing: number;
+}>;
+declare const FollowersOfFilterSchema: z.ZodObject<{
+    followersOf: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    followersOf: number;
+}, {
+    followersOf: number;
+}>;
+declare const FollowingOfFilterSchema: z.ZodObject<{
+    followingOf: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    followingOf: number;
+}, {
+    followingOf: number;
+}>;
+declare const MutualsWithFilterSchema: z.ZodObject<{
+    mutualsWith: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    mutualsWith: number;
+}, {
+    mutualsWith: number;
+}>;
+declare const SignalTokenFilterSchema: z.ZodObject<{
+    signalTokens: z.ZodArray<z.ZodObject<{
+        tokenAddress: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        tokenAddress: string;
+    }, {
+        tokenAddress: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    signalTokens: {
+        tokenAddress: string;
+    }[];
+}, {
+    signalTokens: {
+        tokenAddress: string;
+    }[];
+}>;
+declare const TimezoneFilterSchema: z.ZodObject<{
+    timezones: z.ZodArray<z.ZodObject<{
+        offset: z.ZodNumber;
+        range: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        offset: number;
+        range?: number | undefined;
+    }, {
+        offset: number;
+        range?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    timezones: {
+        offset: number;
+        range?: number | undefined;
+    }[];
+}, {
+    timezones: {
+        offset: number;
+        range?: number | undefined;
+    }[];
+}>;
+declare const CountryFilterSchema: z.ZodObject<{
+    countries: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+    }, {
+        code: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    countries: {
+        code: string;
+    }[];
+}, {
+    countries: {
+        code: string;
+    }[];
+}>;
+declare const RolesFilterSchema: z.ZodObject<{
+    roles: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    roles: string[];
+}, {
+    roles: string[];
+}>;
+declare const SocialFilterSchema: z.ZodObject<{
+    specificIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    specificFids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    specificUsernames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    specificUsersMode: z.ZodOptional<z.ZodEnum<["exclusive", "additive"]>>;
+    excludeFids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    excludeUsernames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    followersOf: z.ZodOptional<z.ZodNumber>;
+    followingOf: z.ZodOptional<z.ZodNumber>;
+    mutualsWith: z.ZodOptional<z.ZodNumber>;
+    minFollowers: z.ZodOptional<z.ZodNumber>;
+    maxFollowers: z.ZodOptional<z.ZodNumber>;
+    minFollowing: z.ZodOptional<z.ZodNumber>;
+    maxFollowing: z.ZodOptional<z.ZodNumber>;
+    signalTokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        tokenAddress: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        tokenAddress: string;
+    }, {
+        tokenAddress: string;
+    }>, "many">>;
+    timezones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        offset: z.ZodNumber;
+        range: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        offset: number;
+        range?: number | undefined;
+    }, {
+        offset: number;
+        range?: number | undefined;
+    }>, "many">>;
+    countries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+    }, {
+        code: string;
+    }>, "many">>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    minFollowers?: number | undefined;
+    maxFollowers?: number | undefined;
+    followersOf?: number | undefined;
+    mutualsWith?: number | undefined;
+    signalTokens?: {
+        tokenAddress: string;
+    }[] | undefined;
+    countries?: {
+        code: string;
+    }[] | undefined;
+    timezones?: {
+        offset: number;
+        range?: number | undefined;
+    }[] | undefined;
+    specificIds?: string[] | undefined;
+    specificFids?: number[] | undefined;
+    specificUsernames?: string[] | undefined;
+    specificUsersMode?: "exclusive" | "additive" | undefined;
+    excludeFids?: number[] | undefined;
+    excludeUsernames?: string[] | undefined;
+    minFollowing?: number | undefined;
+    maxFollowing?: number | undefined;
+    followingOf?: number | undefined;
+    roles?: string[] | undefined;
+}, {
+    minFollowers?: number | undefined;
+    maxFollowers?: number | undefined;
+    followersOf?: number | undefined;
+    mutualsWith?: number | undefined;
+    signalTokens?: {
+        tokenAddress: string;
+    }[] | undefined;
+    countries?: {
+        code: string;
+    }[] | undefined;
+    timezones?: {
+        offset: number;
+        range?: number | undefined;
+    }[] | undefined;
+    specificIds?: string[] | undefined;
+    specificFids?: number[] | undefined;
+    specificUsernames?: string[] | undefined;
+    specificUsersMode?: "exclusive" | "additive" | undefined;
+    excludeFids?: number[] | undefined;
+    excludeUsernames?: string[] | undefined;
+    minFollowing?: number | undefined;
+    maxFollowing?: number | undefined;
+    followingOf?: number | undefined;
+    roles?: string[] | undefined;
+}>;
+declare const ActiveInLastDaysFilterSchema: z.ZodObject<{
+    activeInLastDays: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    activeInLastDays: number;
+}, {
+    activeInLastDays: number;
+}>;
+declare const NeynarScoreMinFilterSchema: z.ZodObject<{
+    neynarScoreMin: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    neynarScoreMin: number;
+}, {
+    neynarScoreMin: number;
+}>;
+declare const NeynarScoreMaxFilterSchema: z.ZodObject<{
+    neynarScoreMax: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    neynarScoreMax: number;
+}, {
+    neynarScoreMax: number;
+}>;
+declare const QuotientScoreMinFilterSchema: z.ZodObject<{
+    quotientScoreMin: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    quotientScoreMin: number;
+}, {
+    quotientScoreMin: number;
+}>;
+declare const QuotientScoreMaxFilterSchema: z.ZodObject<{
+    quotientScoreMax: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    quotientScoreMax: number;
+}, {
+    quotientScoreMax: number;
+}>;
+declare const SpamLabelFilterSchema: z.ZodObject<{
+    spamLabel: z.ZodEnum<["not_spam_only", "spam_only", "all"]>;
+}, "strip", z.ZodTypeAny, {
+    spamLabel: "all" | "not_spam_only" | "spam_only";
+}, {
+    spamLabel: "all" | "not_spam_only" | "spam_only";
+}>;
+declare const ProSubscriptionFilterSchema: z.ZodObject<{
+    proSubscriptionRequired: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    proSubscriptionRequired: boolean;
+}, {
+    proSubscriptionRequired: boolean;
+}>;
+declare const MinProTenureDaysFilterSchema: z.ZodObject<{
+    minProTenureDays: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    minProTenureDays: number;
+}, {
+    minProTenureDays: number;
+}>;
+declare const MinTenureDaysFilterSchema: z.ZodObject<{
+    minTenureDays: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    minTenureDays: number;
+}, {
+    minTenureDays: number;
+}>;
+declare const VerifiedOnlyFilterSchema: z.ZodObject<{
+    verifiedOnly: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    verifiedOnly: boolean;
+}, {
+    verifiedOnly: boolean;
+}>;
+declare const ReputationFilterSchema: z.ZodObject<{
+    neynarScoreMin: z.ZodOptional<z.ZodNumber>;
+    neynarScoreMax: z.ZodOptional<z.ZodNumber>;
+    quotientScoreMin: z.ZodOptional<z.ZodNumber>;
+    quotientScoreMax: z.ZodOptional<z.ZodNumber>;
+    spamLabel: z.ZodOptional<z.ZodEnum<["not_spam_only", "spam_only", "all"]>>;
+    proSubscriptionRequired: z.ZodOptional<z.ZodBoolean>;
+    minProTenureDays: z.ZodOptional<z.ZodNumber>;
+    minTenureDays: z.ZodOptional<z.ZodNumber>;
+    verifiedOnly: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    neynarScoreMin?: number | undefined;
+    neynarScoreMax?: number | undefined;
+    quotientScoreMin?: number | undefined;
+    spamLabel?: "all" | "not_spam_only" | "spam_only" | undefined;
+    verifiedOnly?: boolean | undefined;
+    quotientScoreMax?: number | undefined;
+    proSubscriptionRequired?: boolean | undefined;
+    minProTenureDays?: number | undefined;
+    minTenureDays?: number | undefined;
+}, {
+    neynarScoreMin?: number | undefined;
+    neynarScoreMax?: number | undefined;
+    quotientScoreMin?: number | undefined;
+    spamLabel?: "all" | "not_spam_only" | "spam_only" | undefined;
+    verifiedOnly?: boolean | undefined;
+    quotientScoreMax?: number | undefined;
+    proSubscriptionRequired?: boolean | undefined;
+    minProTenureDays?: number | undefined;
+    minTenureDays?: number | undefined;
+}>;
+declare const MaxAttentionPriceFilterSchema: z.ZodObject<{
+    maxAttentionPriceUsd: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    maxAttentionPriceUsd: number;
+}, {
+    maxAttentionPriceUsd: number;
+}>;
+declare const MinAttentionPriceFilterSchema: z.ZodObject<{
+    minAttentionPriceUsd: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    minAttentionPriceUsd: number;
+}, {
+    minAttentionPriceUsd: number;
+}>;
+declare const MinFidFilterSchema: z.ZodObject<{
+    minFid: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    minFid: number;
+}, {
+    minFid: number;
+}>;
+declare const MaxFidFilterSchema: z.ZodObject<{
+    maxFid: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    maxFid: number;
+}, {
+    maxFid: number;
+}>;
+declare const MinBatteryPercentageFilterSchema: z.ZodObject<{
+    minBatteryPercentage: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    minBatteryPercentage: number;
+}, {
+    minBatteryPercentage: number;
+}>;
+declare const ExcludePingedTodayFilterSchema: z.ZodObject<{
+    excludePingedToday: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    excludePingedToday: boolean;
+}, {
+    excludePingedToday: boolean;
+}>;
+declare const HasRechargedInLastDaysFilterSchema: z.ZodObject<{
+    hasRechargedInLastDays: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    hasRechargedInLastDays: number;
+}, {
+    hasRechargedInLastDays: number;
+}>;
+declare const RequireLotteryOptInFilterSchema: z.ZodObject<{
+    requireLotteryOptIn: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    requireLotteryOptIn: boolean;
+}, {
+    requireLotteryOptIn: boolean;
+}>;
+declare const RequireQuizOptInFilterSchema: z.ZodObject<{
+    requireQuizOptIn: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    requireQuizOptIn: boolean;
+}, {
+    requireQuizOptIn: boolean;
+}>;
+declare const MinCastCountFilterSchema: z.ZodObject<{
+    minCastCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    minCastCount: number;
+}, {
+    minCastCount: number;
+}>;
+declare const MinClickThroughRateFilterSchema: z.ZodObject<{
+    minClickThroughRate: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    minClickThroughRate: number;
+}, {
+    minClickThroughRate: number;
+}>;
+declare const IsWaitlistedFilterSchema: z.ZodObject<{
+    isWaitlisted: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    isWaitlisted: boolean;
+}, {
+    isWaitlisted: boolean;
+}>;
+declare const HasTierFilterSchema: z.ZodObject<{
+    hasTier: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    hasTier: boolean;
+}, {
+    hasTier: boolean;
+}>;
+declare const BeeperEconomicsFilterSchema: z.ZodObject<{
+    maxAttentionPriceUsd: z.ZodOptional<z.ZodNumber>;
+    minAttentionPriceUsd: z.ZodOptional<z.ZodNumber>;
+    minFid: z.ZodOptional<z.ZodNumber>;
+    maxFid: z.ZodOptional<z.ZodNumber>;
+    minBatteryPercentage: z.ZodOptional<z.ZodNumber>;
+    excludePingedToday: z.ZodOptional<z.ZodBoolean>;
+    hasRechargedInLastDays: z.ZodOptional<z.ZodNumber>;
+    activeInLastDays: z.ZodOptional<z.ZodNumber>;
+    requireLotteryOptIn: z.ZodOptional<z.ZodBoolean>;
+    requireQuizOptIn: z.ZodOptional<z.ZodBoolean>;
+    minCastCount: z.ZodOptional<z.ZodNumber>;
+    minClickThroughRate: z.ZodOptional<z.ZodNumber>;
+    isWaitlisted: z.ZodOptional<z.ZodBoolean>;
+    hasTier: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    activeInLastDays?: number | undefined;
+    minCastCount?: number | undefined;
+    maxAttentionPriceUsd?: number | undefined;
+    minBatteryPercentage?: number | undefined;
+    hasRechargedInLastDays?: number | undefined;
+    excludePingedToday?: boolean | undefined;
+    minAttentionPriceUsd?: number | undefined;
+    minFid?: number | undefined;
+    maxFid?: number | undefined;
+    requireLotteryOptIn?: boolean | undefined;
+    requireQuizOptIn?: boolean | undefined;
+    minClickThroughRate?: number | undefined;
+    isWaitlisted?: boolean | undefined;
+    hasTier?: boolean | undefined;
+}, {
+    activeInLastDays?: number | undefined;
+    minCastCount?: number | undefined;
+    maxAttentionPriceUsd?: number | undefined;
+    minBatteryPercentage?: number | undefined;
+    hasRechargedInLastDays?: number | undefined;
+    excludePingedToday?: boolean | undefined;
+    minAttentionPriceUsd?: number | undefined;
+    minFid?: number | undefined;
+    maxFid?: number | undefined;
+    requireLotteryOptIn?: boolean | undefined;
+    requireQuizOptIn?: boolean | undefined;
+    minClickThroughRate?: number | undefined;
+    isWaitlisted?: boolean | undefined;
+    hasTier?: boolean | undefined;
+}>;
+declare const TokenHolderFilterSchema: z.ZodObject<{
+    tokenHolder: z.ZodObject<{
+        chain: z.ZodEnum<["base", "ethereum"]>;
+        contractAddress: z.ZodString;
+        tokenStandard: z.ZodEnum<["ERC20", "ERC721", "ERC1155"]>;
+        tokenId: z.ZodOptional<z.ZodString>;
+        minBalance: z.ZodOptional<z.ZodString>;
+        symbol: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        symbol?: string | undefined;
+        name?: string | undefined;
+        minBalance?: string | undefined;
+        tokenId?: string | undefined;
+    }, {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        symbol?: string | undefined;
+        name?: string | undefined;
+        minBalance?: string | undefined;
+        tokenId?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    tokenHolder: {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        symbol?: string | undefined;
+        name?: string | undefined;
+        minBalance?: string | undefined;
+        tokenId?: string | undefined;
+    };
+}, {
+    tokenHolder: {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        symbol?: string | undefined;
+        name?: string | undefined;
+        minBalance?: string | undefined;
+        tokenId?: string | undefined;
+    };
+}>;
+declare const CachedTokenHolderFilterSchema: z.ZodObject<{
+    cachedTokenHolder: z.ZodObject<{
+        chain: z.ZodEnum<["base", "ethereum"]>;
+        contractAddress: z.ZodString;
+        tokenStandard: z.ZodDefault<z.ZodEnum<["ERC20", "ERC721", "ERC1155"]>>;
+        tokenId: z.ZodOptional<z.ZodString>;
+        tokenSymbol: z.ZodOptional<z.ZodString>;
+        tokenName: z.ZodOptional<z.ZodString>;
+        minBalance: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, "strip", z.ZodTypeAny, {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        minBalance?: string | number | undefined;
+        tokenId?: string | undefined;
+        tokenSymbol?: string | undefined;
+        tokenName?: string | undefined;
+    }, {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        minBalance?: string | number | undefined;
+        tokenStandard?: "ERC20" | "ERC721" | "ERC1155" | undefined;
+        tokenId?: string | undefined;
+        tokenSymbol?: string | undefined;
+        tokenName?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    cachedTokenHolder: {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        minBalance?: string | number | undefined;
+        tokenId?: string | undefined;
+        tokenSymbol?: string | undefined;
+        tokenName?: string | undefined;
+    };
+}, {
+    cachedTokenHolder: {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        minBalance?: string | number | undefined;
+        tokenStandard?: "ERC20" | "ERC721" | "ERC1155" | undefined;
+        tokenId?: string | undefined;
+        tokenSymbol?: string | undefined;
+        tokenName?: string | undefined;
+    };
+}>;
+declare const HasBaseWalletFilterSchema: z.ZodObject<{
+    hasBaseWallet: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    hasBaseWallet: boolean;
+}, {
+    hasBaseWallet: boolean;
+}>;
+declare const HasVerifiedWalletFilterSchema: z.ZodObject<{
+    hasVerifiedWallet: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    hasVerifiedWallet: boolean;
+}, {
+    hasVerifiedWallet: boolean;
+}>;
+declare const TokenHolderDiscoverySchema: z.ZodObject<{
+    chain: z.ZodEnum<["base", "ethereum"]>;
+    contractAddress: z.ZodString;
+    tokenStandard: z.ZodEnum<["ERC20", "ERC721", "ERC1155"]>;
+    tokenId: z.ZodOptional<z.ZodString>;
+    minBalance: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    symbol: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    chain: "base" | "ethereum";
+    contractAddress: string;
+    tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+    symbol?: string | undefined;
+    name?: string | undefined;
+    minBalance?: string | number | undefined;
+    tokenId?: string | undefined;
+}, {
+    chain: "base" | "ethereum";
+    contractAddress: string;
+    tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+    symbol?: string | undefined;
+    name?: string | undefined;
+    minBalance?: string | number | undefined;
+    tokenId?: string | undefined;
+}>;
+declare const CachedTokenHolderSchema: z.ZodObject<{
+    chain: z.ZodEnum<["base", "ethereum"]>;
+    contractAddress: z.ZodString;
+    tokenStandard: z.ZodDefault<z.ZodEnum<["ERC20", "ERC721", "ERC1155"]>>;
+    tokenId: z.ZodOptional<z.ZodString>;
+    tokenSymbol: z.ZodOptional<z.ZodString>;
+    tokenName: z.ZodOptional<z.ZodString>;
+    minBalance: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "strip", z.ZodTypeAny, {
+    chain: "base" | "ethereum";
+    contractAddress: string;
+    tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+    minBalance?: string | number | undefined;
+    tokenId?: string | undefined;
+    tokenSymbol?: string | undefined;
+    tokenName?: string | undefined;
+}, {
+    chain: "base" | "ethereum";
+    contractAddress: string;
+    minBalance?: string | number | undefined;
+    tokenStandard?: "ERC20" | "ERC721" | "ERC1155" | undefined;
+    tokenId?: string | undefined;
+    tokenSymbol?: string | undefined;
+    tokenName?: string | undefined;
+}>;
+declare const OnchainFilterSchema: z.ZodObject<{
+    hasBaseWallet: z.ZodOptional<z.ZodBoolean>;
+    tokenHolders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        chain: z.ZodEnum<["base", "ethereum"]>;
+        contractAddress: z.ZodString;
+        tokenStandard: z.ZodEnum<["ERC20", "ERC721", "ERC1155"]>;
+        tokenId: z.ZodOptional<z.ZodString>;
+        minBalance: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        symbol: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        symbol?: string | undefined;
+        name?: string | undefined;
+        minBalance?: string | number | undefined;
+        tokenId?: string | undefined;
+    }, {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        symbol?: string | undefined;
+        name?: string | undefined;
+        minBalance?: string | number | undefined;
+        tokenId?: string | undefined;
+    }>, "many">>;
+    cachedTokenHolders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        chain: z.ZodEnum<["base", "ethereum"]>;
+        contractAddress: z.ZodString;
+        tokenStandard: z.ZodDefault<z.ZodEnum<["ERC20", "ERC721", "ERC1155"]>>;
+        tokenId: z.ZodOptional<z.ZodString>;
+        tokenSymbol: z.ZodOptional<z.ZodString>;
+        tokenName: z.ZodOptional<z.ZodString>;
+        minBalance: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, "strip", z.ZodTypeAny, {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        minBalance?: string | number | undefined;
+        tokenId?: string | undefined;
+        tokenSymbol?: string | undefined;
+        tokenName?: string | undefined;
+    }, {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        minBalance?: string | number | undefined;
+        tokenStandard?: "ERC20" | "ERC721" | "ERC1155" | undefined;
+        tokenId?: string | undefined;
+        tokenSymbol?: string | undefined;
+        tokenName?: string | undefined;
+    }>, "many">>;
+    hasVerifiedWallet: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    tokenHolders?: {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        symbol?: string | undefined;
+        name?: string | undefined;
+        minBalance?: string | number | undefined;
+        tokenId?: string | undefined;
+    }[] | undefined;
+    hasBaseWallet?: boolean | undefined;
+    hasVerifiedWallet?: boolean | undefined;
+    cachedTokenHolders?: {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        minBalance?: string | number | undefined;
+        tokenId?: string | undefined;
+        tokenSymbol?: string | undefined;
+        tokenName?: string | undefined;
+    }[] | undefined;
+}, {
+    tokenHolders?: {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+        symbol?: string | undefined;
+        name?: string | undefined;
+        minBalance?: string | number | undefined;
+        tokenId?: string | undefined;
+    }[] | undefined;
+    hasBaseWallet?: boolean | undefined;
+    hasVerifiedWallet?: boolean | undefined;
+    cachedTokenHolders?: {
+        chain: "base" | "ethereum";
+        contractAddress: string;
+        minBalance?: string | number | undefined;
+        tokenStandard?: "ERC20" | "ERC721" | "ERC1155" | undefined;
+        tokenId?: string | undefined;
+        tokenSymbol?: string | undefined;
+        tokenName?: string | undefined;
+    }[] | undefined;
+}>;
+declare const OrderBySchema: z.ZodEnum<["attention_price_asc", "attention_price_desc", "neynar_score_desc", "followers_desc", "followers_asc", "recent_activity", "battery_desc", "random"]>;
+/**
+ * Complete Recipient Filter DSL Schema matching backend
+ */
+declare const RecipientFilterSchema: z.ZodObject<{
+    platform: z.ZodOptional<z.ZodEnum<["all", "farcaster", "twitter"]>>;
+    social: z.ZodOptional<z.ZodObject<{
+        specificIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        specificFids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        specificUsernames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        specificUsersMode: z.ZodOptional<z.ZodEnum<["exclusive", "additive"]>>;
+        excludeFids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        excludeUsernames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        followersOf: z.ZodOptional<z.ZodNumber>;
+        followingOf: z.ZodOptional<z.ZodNumber>;
+        mutualsWith: z.ZodOptional<z.ZodNumber>;
+        minFollowers: z.ZodOptional<z.ZodNumber>;
+        maxFollowers: z.ZodOptional<z.ZodNumber>;
+        minFollowing: z.ZodOptional<z.ZodNumber>;
+        maxFollowing: z.ZodOptional<z.ZodNumber>;
+        signalTokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tokenAddress: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            tokenAddress: string;
+        }, {
+            tokenAddress: string;
+        }>, "many">>;
+        timezones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            offset: z.ZodNumber;
+            range: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            offset: number;
+            range?: number | undefined;
+        }, {
+            offset: number;
+            range?: number | undefined;
+        }>, "many">>;
+        countries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+        }, {
+            code: string;
+        }>, "many">>;
+        roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        minFollowers?: number | undefined;
+        maxFollowers?: number | undefined;
+        followersOf?: number | undefined;
+        mutualsWith?: number | undefined;
+        signalTokens?: {
+            tokenAddress: string;
+        }[] | undefined;
+        countries?: {
+            code: string;
+        }[] | undefined;
+        timezones?: {
+            offset: number;
+            range?: number | undefined;
+        }[] | undefined;
+        specificIds?: string[] | undefined;
+        specificFids?: number[] | undefined;
+        specificUsernames?: string[] | undefined;
+        specificUsersMode?: "exclusive" | "additive" | undefined;
+        excludeFids?: number[] | undefined;
+        excludeUsernames?: string[] | undefined;
+        minFollowing?: number | undefined;
+        maxFollowing?: number | undefined;
+        followingOf?: number | undefined;
+        roles?: string[] | undefined;
+    }, {
+        minFollowers?: number | undefined;
+        maxFollowers?: number | undefined;
+        followersOf?: number | undefined;
+        mutualsWith?: number | undefined;
+        signalTokens?: {
+            tokenAddress: string;
+        }[] | undefined;
+        countries?: {
+            code: string;
+        }[] | undefined;
+        timezones?: {
+            offset: number;
+            range?: number | undefined;
+        }[] | undefined;
+        specificIds?: string[] | undefined;
+        specificFids?: number[] | undefined;
+        specificUsernames?: string[] | undefined;
+        specificUsersMode?: "exclusive" | "additive" | undefined;
+        excludeFids?: number[] | undefined;
+        excludeUsernames?: string[] | undefined;
+        minFollowing?: number | undefined;
+        maxFollowing?: number | undefined;
+        followingOf?: number | undefined;
+        roles?: string[] | undefined;
+    }>>;
+    reputation: z.ZodOptional<z.ZodObject<{
+        neynarScoreMin: z.ZodOptional<z.ZodNumber>;
+        neynarScoreMax: z.ZodOptional<z.ZodNumber>;
+        quotientScoreMin: z.ZodOptional<z.ZodNumber>;
+        quotientScoreMax: z.ZodOptional<z.ZodNumber>;
+        spamLabel: z.ZodOptional<z.ZodEnum<["not_spam_only", "spam_only", "all"]>>;
+        proSubscriptionRequired: z.ZodOptional<z.ZodBoolean>;
+        minProTenureDays: z.ZodOptional<z.ZodNumber>;
+        minTenureDays: z.ZodOptional<z.ZodNumber>;
+        verifiedOnly: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        neynarScoreMin?: number | undefined;
+        neynarScoreMax?: number | undefined;
+        quotientScoreMin?: number | undefined;
+        spamLabel?: "all" | "not_spam_only" | "spam_only" | undefined;
+        verifiedOnly?: boolean | undefined;
+        quotientScoreMax?: number | undefined;
+        proSubscriptionRequired?: boolean | undefined;
+        minProTenureDays?: number | undefined;
+        minTenureDays?: number | undefined;
+    }, {
+        neynarScoreMin?: number | undefined;
+        neynarScoreMax?: number | undefined;
+        quotientScoreMin?: number | undefined;
+        spamLabel?: "all" | "not_spam_only" | "spam_only" | undefined;
+        verifiedOnly?: boolean | undefined;
+        quotientScoreMax?: number | undefined;
+        proSubscriptionRequired?: boolean | undefined;
+        minProTenureDays?: number | undefined;
+        minTenureDays?: number | undefined;
+    }>>;
+    onchain: z.ZodOptional<z.ZodObject<{
+        hasBaseWallet: z.ZodOptional<z.ZodBoolean>;
+        tokenHolders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            chain: z.ZodEnum<["base", "ethereum"]>;
+            contractAddress: z.ZodString;
+            tokenStandard: z.ZodEnum<["ERC20", "ERC721", "ERC1155"]>;
+            tokenId: z.ZodOptional<z.ZodString>;
+            minBalance: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+            symbol: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            symbol?: string | undefined;
+            name?: string | undefined;
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+        }, {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            symbol?: string | undefined;
+            name?: string | undefined;
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+        }>, "many">>;
+        cachedTokenHolders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            chain: z.ZodEnum<["base", "ethereum"]>;
+            contractAddress: z.ZodString;
+            tokenStandard: z.ZodDefault<z.ZodEnum<["ERC20", "ERC721", "ERC1155"]>>;
+            tokenId: z.ZodOptional<z.ZodString>;
+            tokenSymbol: z.ZodOptional<z.ZodString>;
+            tokenName: z.ZodOptional<z.ZodString>;
+            minBalance: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        }, "strip", z.ZodTypeAny, {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+            tokenSymbol?: string | undefined;
+            tokenName?: string | undefined;
+        }, {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            minBalance?: string | number | undefined;
+            tokenStandard?: "ERC20" | "ERC721" | "ERC1155" | undefined;
+            tokenId?: string | undefined;
+            tokenSymbol?: string | undefined;
+            tokenName?: string | undefined;
+        }>, "many">>;
+        hasVerifiedWallet: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        tokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            symbol?: string | undefined;
+            name?: string | undefined;
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+        }[] | undefined;
+        hasBaseWallet?: boolean | undefined;
+        hasVerifiedWallet?: boolean | undefined;
+        cachedTokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+            tokenSymbol?: string | undefined;
+            tokenName?: string | undefined;
+        }[] | undefined;
+    }, {
+        tokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            symbol?: string | undefined;
+            name?: string | undefined;
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+        }[] | undefined;
+        hasBaseWallet?: boolean | undefined;
+        hasVerifiedWallet?: boolean | undefined;
+        cachedTokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            minBalance?: string | number | undefined;
+            tokenStandard?: "ERC20" | "ERC721" | "ERC1155" | undefined;
+            tokenId?: string | undefined;
+            tokenSymbol?: string | undefined;
+            tokenName?: string | undefined;
+        }[] | undefined;
+    }>>;
+    beeperEconomics: z.ZodOptional<z.ZodObject<{
+        maxAttentionPriceUsd: z.ZodOptional<z.ZodNumber>;
+        minAttentionPriceUsd: z.ZodOptional<z.ZodNumber>;
+        minFid: z.ZodOptional<z.ZodNumber>;
+        maxFid: z.ZodOptional<z.ZodNumber>;
+        minBatteryPercentage: z.ZodOptional<z.ZodNumber>;
+        excludePingedToday: z.ZodOptional<z.ZodBoolean>;
+        hasRechargedInLastDays: z.ZodOptional<z.ZodNumber>;
+        activeInLastDays: z.ZodOptional<z.ZodNumber>;
+        requireLotteryOptIn: z.ZodOptional<z.ZodBoolean>;
+        requireQuizOptIn: z.ZodOptional<z.ZodBoolean>;
+        minCastCount: z.ZodOptional<z.ZodNumber>;
+        minClickThroughRate: z.ZodOptional<z.ZodNumber>;
+        isWaitlisted: z.ZodOptional<z.ZodBoolean>;
+        hasTier: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        activeInLastDays?: number | undefined;
+        minCastCount?: number | undefined;
+        maxAttentionPriceUsd?: number | undefined;
+        minBatteryPercentage?: number | undefined;
+        hasRechargedInLastDays?: number | undefined;
+        excludePingedToday?: boolean | undefined;
+        minAttentionPriceUsd?: number | undefined;
+        minFid?: number | undefined;
+        maxFid?: number | undefined;
+        requireLotteryOptIn?: boolean | undefined;
+        requireQuizOptIn?: boolean | undefined;
+        minClickThroughRate?: number | undefined;
+        isWaitlisted?: boolean | undefined;
+        hasTier?: boolean | undefined;
+    }, {
+        activeInLastDays?: number | undefined;
+        minCastCount?: number | undefined;
+        maxAttentionPriceUsd?: number | undefined;
+        minBatteryPercentage?: number | undefined;
+        hasRechargedInLastDays?: number | undefined;
+        excludePingedToday?: boolean | undefined;
+        minAttentionPriceUsd?: number | undefined;
+        minFid?: number | undefined;
+        maxFid?: number | undefined;
+        requireLotteryOptIn?: boolean | undefined;
+        requireQuizOptIn?: boolean | undefined;
+        minClickThroughRate?: number | undefined;
+        isWaitlisted?: boolean | undefined;
+        hasTier?: boolean | undefined;
+    }>>;
+    orderBy: z.ZodOptional<z.ZodEnum<["attention_price_asc", "attention_price_desc", "neynar_score_desc", "followers_desc", "followers_asc", "recent_activity", "battery_desc", "random"]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    platform?: "all" | "farcaster" | "twitter" | undefined;
+    orderBy?: "attention_price_asc" | "attention_price_desc" | "neynar_score_desc" | "followers_desc" | "followers_asc" | "recent_activity" | "battery_desc" | "random" | undefined;
+    social?: {
+        minFollowers?: number | undefined;
+        maxFollowers?: number | undefined;
+        followersOf?: number | undefined;
+        mutualsWith?: number | undefined;
+        signalTokens?: {
+            tokenAddress: string;
+        }[] | undefined;
+        countries?: {
+            code: string;
+        }[] | undefined;
+        timezones?: {
+            offset: number;
+            range?: number | undefined;
+        }[] | undefined;
+        specificIds?: string[] | undefined;
+        specificFids?: number[] | undefined;
+        specificUsernames?: string[] | undefined;
+        specificUsersMode?: "exclusive" | "additive" | undefined;
+        excludeFids?: number[] | undefined;
+        excludeUsernames?: string[] | undefined;
+        minFollowing?: number | undefined;
+        maxFollowing?: number | undefined;
+        followingOf?: number | undefined;
+        roles?: string[] | undefined;
+    } | undefined;
+    reputation?: {
+        neynarScoreMin?: number | undefined;
+        neynarScoreMax?: number | undefined;
+        quotientScoreMin?: number | undefined;
+        spamLabel?: "all" | "not_spam_only" | "spam_only" | undefined;
+        verifiedOnly?: boolean | undefined;
+        quotientScoreMax?: number | undefined;
+        proSubscriptionRequired?: boolean | undefined;
+        minProTenureDays?: number | undefined;
+        minTenureDays?: number | undefined;
+    } | undefined;
+    onchain?: {
+        tokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            symbol?: string | undefined;
+            name?: string | undefined;
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+        }[] | undefined;
+        hasBaseWallet?: boolean | undefined;
+        hasVerifiedWallet?: boolean | undefined;
+        cachedTokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+            tokenSymbol?: string | undefined;
+            tokenName?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    beeperEconomics?: {
+        activeInLastDays?: number | undefined;
+        minCastCount?: number | undefined;
+        maxAttentionPriceUsd?: number | undefined;
+        minBatteryPercentage?: number | undefined;
+        hasRechargedInLastDays?: number | undefined;
+        excludePingedToday?: boolean | undefined;
+        minAttentionPriceUsd?: number | undefined;
+        minFid?: number | undefined;
+        maxFid?: number | undefined;
+        requireLotteryOptIn?: boolean | undefined;
+        requireQuizOptIn?: boolean | undefined;
+        minClickThroughRate?: number | undefined;
+        isWaitlisted?: boolean | undefined;
+        hasTier?: boolean | undefined;
+    } | undefined;
+    limit?: number | undefined;
+}, {
+    platform?: "all" | "farcaster" | "twitter" | undefined;
+    orderBy?: "attention_price_asc" | "attention_price_desc" | "neynar_score_desc" | "followers_desc" | "followers_asc" | "recent_activity" | "battery_desc" | "random" | undefined;
+    social?: {
+        minFollowers?: number | undefined;
+        maxFollowers?: number | undefined;
+        followersOf?: number | undefined;
+        mutualsWith?: number | undefined;
+        signalTokens?: {
+            tokenAddress: string;
+        }[] | undefined;
+        countries?: {
+            code: string;
+        }[] | undefined;
+        timezones?: {
+            offset: number;
+            range?: number | undefined;
+        }[] | undefined;
+        specificIds?: string[] | undefined;
+        specificFids?: number[] | undefined;
+        specificUsernames?: string[] | undefined;
+        specificUsersMode?: "exclusive" | "additive" | undefined;
+        excludeFids?: number[] | undefined;
+        excludeUsernames?: string[] | undefined;
+        minFollowing?: number | undefined;
+        maxFollowing?: number | undefined;
+        followingOf?: number | undefined;
+        roles?: string[] | undefined;
+    } | undefined;
+    reputation?: {
+        neynarScoreMin?: number | undefined;
+        neynarScoreMax?: number | undefined;
+        quotientScoreMin?: number | undefined;
+        spamLabel?: "all" | "not_spam_only" | "spam_only" | undefined;
+        verifiedOnly?: boolean | undefined;
+        quotientScoreMax?: number | undefined;
+        proSubscriptionRequired?: boolean | undefined;
+        minProTenureDays?: number | undefined;
+        minTenureDays?: number | undefined;
+    } | undefined;
+    onchain?: {
+        tokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            symbol?: string | undefined;
+            name?: string | undefined;
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+        }[] | undefined;
+        hasBaseWallet?: boolean | undefined;
+        hasVerifiedWallet?: boolean | undefined;
+        cachedTokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            minBalance?: string | number | undefined;
+            tokenStandard?: "ERC20" | "ERC721" | "ERC1155" | undefined;
+            tokenId?: string | undefined;
+            tokenSymbol?: string | undefined;
+            tokenName?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    beeperEconomics?: {
+        activeInLastDays?: number | undefined;
+        minCastCount?: number | undefined;
+        maxAttentionPriceUsd?: number | undefined;
+        minBatteryPercentage?: number | undefined;
+        hasRechargedInLastDays?: number | undefined;
+        excludePingedToday?: boolean | undefined;
+        minAttentionPriceUsd?: number | undefined;
+        minFid?: number | undefined;
+        maxFid?: number | undefined;
+        requireLotteryOptIn?: boolean | undefined;
+        requireQuizOptIn?: boolean | undefined;
+        minClickThroughRate?: number | undefined;
+        isWaitlisted?: boolean | undefined;
+        hasTier?: boolean | undefined;
+    } | undefined;
+    limit?: number | undefined;
+}>;
+/**
+ * Filter expression supporting logical combinators
+ */
+declare const FilterExpressionSchema: z.ZodType<unknown>;
+declare const RecipientFilterDSLSchema: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+type PlatformFilter = z.infer<typeof PlatformFilterSchema>;
+type SocialFilter = z.infer<typeof SocialFilterSchema>;
+type ReputationFilter = z.infer<typeof ReputationFilterSchema>;
+type OnchainFilter = z.infer<typeof OnchainFilterSchema>;
+type BeeperEconomicsFilter = z.infer<typeof BeeperEconomicsFilterSchema>;
+type RecipientFilter = z.infer<typeof RecipientFilterSchema>;
+type FilterExpression = z.infer<typeof FilterExpressionSchema>;
+type OrderBy = z.infer<typeof OrderBySchema>;
+type TokenHolderDiscovery = z.infer<typeof TokenHolderDiscoverySchema>;
+type CachedTokenHolder = z.infer<typeof CachedTokenHolderSchema>;
+type LegacyFilterOperator = z.infer<typeof LegacyFilterOperatorSchema>;
+type LegacyFilterValue = z.infer<typeof LegacyFilterValueSchema>;
+type LegacyFieldComparison = z.infer<typeof LegacyFieldComparisonSchema>;
+/**
+ * Validate a filter DSL expression
+ */
+declare function validateFilter(filter: unknown): boolean;
+/**
+ * Parse and validate a filter DSL expression
+ */
+declare function parseFilter(filter: unknown): unknown;
+/**
+ * Safely parse a filter DSL expression
+ */
+declare function safeParseFilter(filter: unknown): z.SafeParseReturnType<unknown, unknown>;
+/**
+ * Validate a structured recipient filter
+ */
+declare function validateRecipientFilter(filter: unknown): boolean;
+/**
+ * Parse and validate a structured recipient filter
+ */
+declare function parseRecipientFilter(filter: unknown): {
+    platform?: "all" | "farcaster" | "twitter" | undefined;
+    orderBy?: "attention_price_asc" | "attention_price_desc" | "neynar_score_desc" | "followers_desc" | "followers_asc" | "recent_activity" | "battery_desc" | "random" | undefined;
+    social?: {
+        minFollowers?: number | undefined;
+        maxFollowers?: number | undefined;
+        followersOf?: number | undefined;
+        mutualsWith?: number | undefined;
+        signalTokens?: {
+            tokenAddress: string;
+        }[] | undefined;
+        countries?: {
+            code: string;
+        }[] | undefined;
+        timezones?: {
+            offset: number;
+            range?: number | undefined;
+        }[] | undefined;
+        specificIds?: string[] | undefined;
+        specificFids?: number[] | undefined;
+        specificUsernames?: string[] | undefined;
+        specificUsersMode?: "exclusive" | "additive" | undefined;
+        excludeFids?: number[] | undefined;
+        excludeUsernames?: string[] | undefined;
+        minFollowing?: number | undefined;
+        maxFollowing?: number | undefined;
+        followingOf?: number | undefined;
+        roles?: string[] | undefined;
+    } | undefined;
+    reputation?: {
+        neynarScoreMin?: number | undefined;
+        neynarScoreMax?: number | undefined;
+        quotientScoreMin?: number | undefined;
+        spamLabel?: "all" | "not_spam_only" | "spam_only" | undefined;
+        verifiedOnly?: boolean | undefined;
+        quotientScoreMax?: number | undefined;
+        proSubscriptionRequired?: boolean | undefined;
+        minProTenureDays?: number | undefined;
+        minTenureDays?: number | undefined;
+    } | undefined;
+    onchain?: {
+        tokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            symbol?: string | undefined;
+            name?: string | undefined;
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+        }[] | undefined;
+        hasBaseWallet?: boolean | undefined;
+        hasVerifiedWallet?: boolean | undefined;
+        cachedTokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+            tokenSymbol?: string | undefined;
+            tokenName?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    beeperEconomics?: {
+        activeInLastDays?: number | undefined;
+        minCastCount?: number | undefined;
+        maxAttentionPriceUsd?: number | undefined;
+        minBatteryPercentage?: number | undefined;
+        hasRechargedInLastDays?: number | undefined;
+        excludePingedToday?: boolean | undefined;
+        minAttentionPriceUsd?: number | undefined;
+        minFid?: number | undefined;
+        maxFid?: number | undefined;
+        requireLotteryOptIn?: boolean | undefined;
+        requireQuizOptIn?: boolean | undefined;
+        minClickThroughRate?: number | undefined;
+        isWaitlisted?: boolean | undefined;
+        hasTier?: boolean | undefined;
+    } | undefined;
+    limit?: number | undefined;
+};
+/**
+ * Safely parse a structured recipient filter
+ */
+declare function safeParseRecipientFilter(filter: unknown): z.SafeParseReturnType<{
+    platform?: "all" | "farcaster" | "twitter" | undefined;
+    orderBy?: "attention_price_asc" | "attention_price_desc" | "neynar_score_desc" | "followers_desc" | "followers_asc" | "recent_activity" | "battery_desc" | "random" | undefined;
+    social?: {
+        minFollowers?: number | undefined;
+        maxFollowers?: number | undefined;
+        followersOf?: number | undefined;
+        mutualsWith?: number | undefined;
+        signalTokens?: {
+            tokenAddress: string;
+        }[] | undefined;
+        countries?: {
+            code: string;
+        }[] | undefined;
+        timezones?: {
+            offset: number;
+            range?: number | undefined;
+        }[] | undefined;
+        specificIds?: string[] | undefined;
+        specificFids?: number[] | undefined;
+        specificUsernames?: string[] | undefined;
+        specificUsersMode?: "exclusive" | "additive" | undefined;
+        excludeFids?: number[] | undefined;
+        excludeUsernames?: string[] | undefined;
+        minFollowing?: number | undefined;
+        maxFollowing?: number | undefined;
+        followingOf?: number | undefined;
+        roles?: string[] | undefined;
+    } | undefined;
+    reputation?: {
+        neynarScoreMin?: number | undefined;
+        neynarScoreMax?: number | undefined;
+        quotientScoreMin?: number | undefined;
+        spamLabel?: "all" | "not_spam_only" | "spam_only" | undefined;
+        verifiedOnly?: boolean | undefined;
+        quotientScoreMax?: number | undefined;
+        proSubscriptionRequired?: boolean | undefined;
+        minProTenureDays?: number | undefined;
+        minTenureDays?: number | undefined;
+    } | undefined;
+    onchain?: {
+        tokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            symbol?: string | undefined;
+            name?: string | undefined;
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+        }[] | undefined;
+        hasBaseWallet?: boolean | undefined;
+        hasVerifiedWallet?: boolean | undefined;
+        cachedTokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            minBalance?: string | number | undefined;
+            tokenStandard?: "ERC20" | "ERC721" | "ERC1155" | undefined;
+            tokenId?: string | undefined;
+            tokenSymbol?: string | undefined;
+            tokenName?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    beeperEconomics?: {
+        activeInLastDays?: number | undefined;
+        minCastCount?: number | undefined;
+        maxAttentionPriceUsd?: number | undefined;
+        minBatteryPercentage?: number | undefined;
+        hasRechargedInLastDays?: number | undefined;
+        excludePingedToday?: boolean | undefined;
+        minAttentionPriceUsd?: number | undefined;
+        minFid?: number | undefined;
+        maxFid?: number | undefined;
+        requireLotteryOptIn?: boolean | undefined;
+        requireQuizOptIn?: boolean | undefined;
+        minClickThroughRate?: number | undefined;
+        isWaitlisted?: boolean | undefined;
+        hasTier?: boolean | undefined;
+    } | undefined;
+    limit?: number | undefined;
+}, {
+    platform?: "all" | "farcaster" | "twitter" | undefined;
+    orderBy?: "attention_price_asc" | "attention_price_desc" | "neynar_score_desc" | "followers_desc" | "followers_asc" | "recent_activity" | "battery_desc" | "random" | undefined;
+    social?: {
+        minFollowers?: number | undefined;
+        maxFollowers?: number | undefined;
+        followersOf?: number | undefined;
+        mutualsWith?: number | undefined;
+        signalTokens?: {
+            tokenAddress: string;
+        }[] | undefined;
+        countries?: {
+            code: string;
+        }[] | undefined;
+        timezones?: {
+            offset: number;
+            range?: number | undefined;
+        }[] | undefined;
+        specificIds?: string[] | undefined;
+        specificFids?: number[] | undefined;
+        specificUsernames?: string[] | undefined;
+        specificUsersMode?: "exclusive" | "additive" | undefined;
+        excludeFids?: number[] | undefined;
+        excludeUsernames?: string[] | undefined;
+        minFollowing?: number | undefined;
+        maxFollowing?: number | undefined;
+        followingOf?: number | undefined;
+        roles?: string[] | undefined;
+    } | undefined;
+    reputation?: {
+        neynarScoreMin?: number | undefined;
+        neynarScoreMax?: number | undefined;
+        quotientScoreMin?: number | undefined;
+        spamLabel?: "all" | "not_spam_only" | "spam_only" | undefined;
+        verifiedOnly?: boolean | undefined;
+        quotientScoreMax?: number | undefined;
+        proSubscriptionRequired?: boolean | undefined;
+        minProTenureDays?: number | undefined;
+        minTenureDays?: number | undefined;
+    } | undefined;
+    onchain?: {
+        tokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            symbol?: string | undefined;
+            name?: string | undefined;
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+        }[] | undefined;
+        hasBaseWallet?: boolean | undefined;
+        hasVerifiedWallet?: boolean | undefined;
+        cachedTokenHolders?: {
+            chain: "base" | "ethereum";
+            contractAddress: string;
+            tokenStandard: "ERC20" | "ERC721" | "ERC1155";
+            minBalance?: string | number | undefined;
+            tokenId?: string | undefined;
+            tokenSymbol?: string | undefined;
+            tokenName?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    beeperEconomics?: {
+        activeInLastDays?: number | undefined;
+        minCastCount?: number | undefined;
+        maxAttentionPriceUsd?: number | undefined;
+        minBatteryPercentage?: number | undefined;
+        hasRechargedInLastDays?: number | undefined;
+        excludePingedToday?: boolean | undefined;
+        minAttentionPriceUsd?: number | undefined;
+        minFid?: number | undefined;
+        maxFid?: number | undefined;
+        requireLotteryOptIn?: boolean | undefined;
+        requireQuizOptIn?: boolean | undefined;
+        minClickThroughRate?: number | undefined;
+        isWaitlisted?: boolean | undefined;
+        hasTier?: boolean | undefined;
+    } | undefined;
+    limit?: number | undefined;
+}>;
+/**
+ * Validate that a filter has at least some targeting criteria
+ */
+declare function validateFilterHasTargeting(filter: RecipientFilter): boolean;
+/**
+ * Get human-readable description of filters
+ */
+declare function describeFilters(filter: RecipientFilter): string[];
+
+export { API_BASE_URLS, API_KEY_PREFIXES, ActiveInLastDaysFilterSchema, AgentClient, type AgentClientConfig, type User as AgentUser, type ApiError, type ApiKey, type ApiQuoteResponse, ApiQuoteResponseSchema, type ApiReceiptResponse, ApiReceiptResponseSchema, type AttentionMarketplaceInput, type AttentionPrice, BeeperClient, type BeeperClientConfig, type BeeperConfig, BeeperEconomicsFilterSchema, type BeeperEconomicsFilter as BeeperEconomicsFilterSchemaType, BeeperError, type BeeperErrorOptions, type BulkIntentInput, type BulkIntentResult, CachedTokenHolderFilterSchema, CachedTokenHolderSchema, type CachedTokenHolder as CachedTokenHolderSchemaType, type ConfirmResult as ClientConfirmResult, type Draft$2 as ClientDraft, type DraftInput$1 as ClientDraftInput, type ExecuteResult$1 as ClientExecuteResult, type FilterExpression$2 as ClientFilterExpression, type Health$1 as ClientHealth, type Quote$1 as ClientQuote, type QuoteOptions$1 as ClientQuoteOptions, type Receipt$1 as ClientReceipt, type ReceiptTransaction$1 as ClientReceiptTransaction, type ConfirmDepositInput, type ConfirmDepositParams, type ConfirmDepositResponse, ConfirmDepositResponseSchema, type ConfirmDepositResult, ConfirmResultSchema, CountryFilterSchema, type CreateApiKeyInput, type CreateIntentInput, type CreateQuoteInput, DistributionStrategySchema, DraftInputSchema, DraftSchema, DraftStatusSchema, DraftUpdateSchema, ENDPOINTS, type Environment, type ErrorCode, ErrorCodes, type ErrorContext, type EstimateInput, type EstimateResult, ExcludePingedTodayFilterSchema, ExcludeUsersFilterSchema, type ExecuteResult, ExecuteResultSchema, type ExecuteSendParams, type ExecuteSendResponse, ExecuteSendResponseSchema, ExecuteStatusSchema, FILTER_SCHEMA, FieldComparisonSchema, FilterBuilder, type FilterCategory, FilterExpression$1 as FilterExpression, type FilterExpressionJSON, FilterExpressionSchema, type FilterExpression as FilterExpressionSchemaType, type FilterFieldSchema, FilterOperatorSchema, FilterValueSchema, FollowersOfFilterSchema, FollowingOfFilterSchema, GasTierSchema, HEADERS, HTTP_STATUS_TO_ERROR_CODE, HasBaseWalletFilterSchema, HasRechargedInLastDaysFilterSchema, HasTierFilterSchema, HasVerifiedWalletFilterSchema, type Health, HttpClient, type HttpClientConfig, type HttpRequestOptions, type HttpResponse, IsWaitlistedFilterSchema, type LegacyFieldComparison, LegacyFieldComparisonSchema, type LegacyFilterOperator, LegacyFilterOperatorSchema, type LegacyFilterValue, LegacyFilterValueSchema, LegacyRecipientFilterDSLSchema, MaxAttentionPriceFilterSchema, MaxFidFilterSchema, MaxFollowersFilterSchema, MaxFollowingFilterSchema, MinAttentionPriceFilterSchema, MinBatteryPercentageFilterSchema, MinCastCountFilterSchema, MinClickThroughRateFilterSchema, MinFidFilterSchema, MinFollowersFilterSchema, MinFollowingFilterSchema, MinProTenureDaysFilterSchema, MinTenureDaysFilterSchema, MutualsWithFilterSchema, NetworkSchema, NeynarScoreMaxFilterSchema, NeynarScoreMinFilterSchema, OnchainFilterSchema, type OnchainFilter as OnchainFilterSchemaType, type OrderBy$1 as OrderBy, type OrderByOption, OrderBySchema, type OrderBy as OrderBySchemaType, type PaymentIntent, PlatformFilterSchema, type PlatformFilter as PlatformFilterSchemaType, type PollOptions$1 as PollOptions, type PreviewInput, type PreviewResult, type PreviewUser, ProSubscriptionFilterSchema, QUOTE_EXPIRATION_SECONDS, type Quote, QuoteOptionsSchema, QuoteRecipientSchema, QuoteSchema, type QuoteStatus$2 as QuoteStatus, QuotientScoreMaxFilterSchema, QuotientScoreMinFilterSchema, RETRYABLE_ERROR_CODES, RETRY_CONFIG, type Receipt, ReceiptSchema, type ReceiptStatus, ReceiptTransactionSchema, ReceiptTransferSchema, type RecipientFilter$1 as RecipientFilter, RecipientFilterDSLSchema, RecipientFilterSchema, type RecipientFilter as RecipientFilterSchemaType, ReputationFilterSchema, type ReputationFilter as ReputationFilterSchemaType, RequireLotteryOptInFilterSchema, RequireQuizOptInFilterSchema, type RetryOptions, type RewardType, RolesFilterSchema, SDK_VERSION, type PollOptions as SendPollOptions, type QuoteStatus$1 as SendQuoteStatus, type ReceiptTransaction as SendReceiptTransaction, SignalTokenFilterSchema, type SimpleFilters, SocialFilterSchema, type SocialFilter as SocialFilterSchemaType, SpamLabelFilterSchema, type SpamLabelOption, SpecificUsersFilterSchema, type SupportedChainId, TIMEOUTS, TimezoneFilterSchema, type TimezoneOptions, type TokenDistributionInput, type TokenHolderConfig, TokenHolderDiscoverySchema, type TokenHolderDiscovery as TokenHolderDiscoverySchemaType, TokenHolderFilterSchema, type TokenHolderOptions, type TokenStandard, TokenTypeSchema, TransferStatusSchema, VerifiedOnlyFilterSchema, createAuthorizationHeader, createHttpConfig, BeeperClient as default, describeFilters, generateDepositIdempotencyKey, generateExecuteIdempotencyKey, generateFilterDocumentation, generateIdempotencyKey, getAllFilterNames, getApiKeyEnvironment, getFilterSchema, isRetryableCode, isValidApiKeyFormat, maskApiKey, parseDraft, parseDraftInput, parseExecuteResult, parseFilter, parseQuote, parseQuoteOptions, parseReceipt, parseRecipientFilter, safeParseFilter, safeParseRecipientFilter, confirmDeposit as sendConfirmDeposit, createDraft as sendCreateDraft, createQuote as sendCreateQuote, executeSend as sendExecuteSend, getEstimatedTimeRemaining as sendGetEstimatedTimeRemaining, getFailedTransactions as sendGetFailedTransactions, getQuote as sendGetQuote, getReceipt as sendGetReceipt, getSuccessRate as sendGetSuccessRate, isComplete as sendIsComplete, isDepositSufficient as sendIsDepositSufficient, isExecuting as sendIsExecuting, isQuoteExpired as sendIsQuoteExpired, isReadyForDeposit as sendIsReadyForDeposit, isReadyForQuote as sendIsReadyForQuote, isSuccess as sendIsSuccess, pollUntilComplete as sendPollUntilComplete, updateDraft as sendUpdateDraft, validateDraftInput as sendValidateDraftInput, validateDraft, validateDraftInput$1 as validateDraftInput, validateExecuteResult, validateFilter, validateFilterHasTargeting, validateQuote, validateQuoteOptions, validateReceipt, validateRecipientFilter };