@beeperbot/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,3202 @@
+import { z } from 'zod';
+import { randomUUID } from 'crypto';
+
+// src/client/http.ts
+
+// src/errors/codes.ts
+var ErrorCodes = {
+  // Quote-related errors
+  QUOTE_EXPIRED: "QUOTE_EXPIRED",
+  QUOTE_NOT_FOUND: "QUOTE_NOT_FOUND",
+  QUOTE_INVALID: "QUOTE_INVALID",
+  // Recipient-related errors
+  INVALID_RECIPIENT: "INVALID_RECIPIENT",
+  RECIPIENT_NOT_FOUND: "RECIPIENT_NOT_FOUND",
+  // Filter-related errors
+  INVALID_FILTER: "INVALID_FILTER",
+  FILTER_SYNTAX_ERROR: "FILTER_SYNTAX_ERROR",
+  // Budget-related errors
+  BUDGET_TOO_LOW: "BUDGET_TOO_LOW",
+  BUDGET_EXCEEDED: "BUDGET_EXCEEDED",
+  // Payment-related errors
+  PAYMENT_NOT_FOUND: "PAYMENT_NOT_FOUND",
+  PAYMENT_INSUFFICIENT: "PAYMENT_INSUFFICIENT",
+  PAYMENT_FAILED: "PAYMENT_FAILED",
+  // Execution-related errors
+  EXECUTION_ALREADY_TRIGGERED: "EXECUTION_ALREADY_TRIGGERED",
+  EXECUTION_FAILED: "EXECUTION_FAILED",
+  EXECUTION_PENDING: "EXECUTION_PENDING",
+  // Rate limiting
+  RATE_LIMITED: "RATE_LIMITED",
+  // Authentication/Authorization
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  API_KEY_INVALID: "API_KEY_INVALID",
+  // Network errors
+  NETWORK_ERROR: "NETWORK_ERROR",
+  TIMEOUT: "TIMEOUT",
+  CONNECTION_REFUSED: "CONNECTION_REFUSED",
+  // Validation errors
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  SCHEMA_VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED",
+  // Server errors
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  // Draft errors
+  DRAFT_NOT_FOUND: "DRAFT_NOT_FOUND",
+  DRAFT_INVALID: "DRAFT_INVALID",
+  // Generic
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+var RETRYABLE_ERROR_CODES = [
+  ErrorCodes.RATE_LIMITED,
+  ErrorCodes.NETWORK_ERROR,
+  ErrorCodes.TIMEOUT,
+  ErrorCodes.CONNECTION_REFUSED,
+  ErrorCodes.SERVICE_UNAVAILABLE,
+  ErrorCodes.INTERNAL_ERROR
+];
+function isRetryableCode(code) {
+  return RETRYABLE_ERROR_CODES.includes(code);
+}
+var HTTP_STATUS_TO_ERROR_CODE = {
+  400: ErrorCodes.VALIDATION_ERROR,
+  401: ErrorCodes.UNAUTHORIZED,
+  403: ErrorCodes.FORBIDDEN,
+  404: ErrorCodes.UNKNOWN_ERROR,
+  // Specific 404s are mapped differently
+  408: ErrorCodes.TIMEOUT,
+  429: ErrorCodes.RATE_LIMITED,
+  500: ErrorCodes.INTERNAL_ERROR,
+  502: ErrorCodes.SERVICE_UNAVAILABLE,
+  503: ErrorCodes.SERVICE_UNAVAILABLE,
+  504: ErrorCodes.TIMEOUT
+};
+
+// src/errors/BeeperError.ts
+var BeeperError = class _BeeperError extends Error {
+  /** Error code identifying the type of error */
+  code;
+  /** Whether this error can be retried */
+  retryable;
+  /** Additional context about the error */
+  context;
+  /** The original error that caused this error */
+  cause;
+  constructor(options) {
+    super(options.message);
+    this.name = "BeeperError";
+    this.code = options.code;
+    this.cause = options.cause;
+    this.context = options.context ?? {};
+    this.retryable = options.retryable ?? isRetryableCode(options.code);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _BeeperError);
+    }
+  }
+  /**
+   * Create a string representation of the error
+   */
+  toString() {
+    let str = `BeeperError [${this.code}]: ${this.message}`;
+    if (this.context.requestId) {
+      str += ` (Request ID: ${this.context.requestId})`;
+    }
+    return str;
+  }
+  /**
+   * Convert to a plain object for logging/serialization
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      retryable: this.retryable,
+      context: this.context,
+      stack: this.stack
+    };
+  }
+  /**
+   * Create a network error
+   */
+  static networkError(message, cause) {
+    const options = {
+      code: ErrorCodes.NETWORK_ERROR,
+      message,
+      retryable: true
+    };
+    if (cause !== void 0) {
+      options.cause = cause;
+    }
+    return new _BeeperError(options);
+  }
+  /**
+   * Create a timeout error
+   */
+  static timeout(endpoint, timeoutMs) {
+    return new _BeeperError({
+      code: ErrorCodes.TIMEOUT,
+      message: `Request to ${endpoint} timed out after ${timeoutMs}ms`,
+      context: { endpoint },
+      retryable: true
+    });
+  }
+  /**
+   * Create an unauthorized error
+   */
+  static unauthorized(message = "Invalid or missing API key") {
+    return new _BeeperError({
+      code: ErrorCodes.UNAUTHORIZED,
+      message,
+      retryable: false
+    });
+  }
+  /**
+   * Create a rate limited error
+   */
+  static rateLimited(retryAfter) {
+    const context = {};
+    if (retryAfter !== void 0) {
+      context.retryAfter = retryAfter;
+    }
+    return new _BeeperError({
+      code: ErrorCodes.RATE_LIMITED,
+      message: retryAfter ? `Rate limited. Retry after ${retryAfter} seconds` : "Rate limited. Please try again later",
+      context,
+      retryable: true
+    });
+  }
+  /**
+   * Create a validation error
+   */
+  static validation(message, details) {
+    const context = {};
+    if (details !== void 0) {
+      context.details = details;
+    }
+    return new _BeeperError({
+      code: ErrorCodes.VALIDATION_ERROR,
+      message,
+      context,
+      retryable: false
+    });
+  }
+  /**
+   * Create a quote expired error
+   */
+  static quoteExpired(quoteId) {
+    return new _BeeperError({
+      code: ErrorCodes.QUOTE_EXPIRED,
+      message: `Quote ${quoteId} has expired`,
+      context: { details: { quoteId } },
+      retryable: false
+    });
+  }
+  /**
+   * Create from an HTTP response
+   */
+  static fromHttpResponse(statusCode, body, requestId) {
+    const rawBody = body;
+    const errorData = rawBody?.error ?? rawBody;
+    const code = errorData?.code ?? ErrorCodes.UNKNOWN_ERROR;
+    const message = errorData?.message ?? `HTTP ${statusCode} error`;
+    const context = { statusCode };
+    if (requestId !== void 0) {
+      context.requestId = requestId;
+    }
+    if (errorData?.details !== void 0) {
+      context.details = errorData.details;
+    }
+    return new _BeeperError({
+      code,
+      message,
+      context
+    });
+  }
+};
+
+// src/constants.ts
+var API_BASE_URLS = {
+  production: "https://beep.works/api/v1/sdk",
+  staging: "https://staging.beep.works/api/v1/sdk",
+  development: "http://localhost:3000/api/v1/sdk"
+};
+var TIMEOUTS = {
+  /** Default request timeout */
+  DEFAULT: 3e4,
+  /** Timeout for quote requests */
+  QUOTE: 1e4,
+  /** Timeout for execute requests (longer due to blockchain) */
+  EXECUTE: 6e4,
+  /** Timeout for health checks */
+  HEALTH: 5e3
+};
+var ENDPOINTS = {
+  HEALTH: "/send/health",
+  QUOTES: "/send/quotes",
+  KEYS: "/keys"
+};
+var HEADERS = {
+  IDEMPOTENCY_KEY: "Idempotency-Key",
+  AUTHORIZATION: "Authorization",
+  REQUEST_ID: "X-Request-Id",
+  CONTENT_TYPE: "Content-Type"
+};
+var RETRY_CONFIG = {
+  /** Maximum number of retry attempts */
+  MAX_RETRIES: 3,
+  /** Initial delay before first retry (1 second) */
+  INITIAL_DELAY_MS: 1e3,
+  /** Maximum delay between retries (30 seconds) */
+  MAX_DELAY_MS: 3e4,
+  /** Multiplier for exponential backoff */
+  BACKOFF_MULTIPLIER: 2,
+  /** Jitter factor to add randomness (0-1) */
+  JITTER_FACTOR: 0.1
+};
+var QUOTE_EXPIRATION_SECONDS = 300;
+var SDK_VERSION = "0.1.0";
+
+// src/client/http.ts
+function createHttpConfig(options) {
+  const baseUrl = options.baseUrl ?? API_BASE_URLS[options.environment ?? "production"];
+  return {
+    apiKey: options.apiKey,
+    baseUrl,
+    timeout: options.timeout ?? TIMEOUTS.DEFAULT,
+    fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
+    debug: options.debug ?? false
+  };
+}
+var HttpClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Check if an HTTP status code is retryable
+   * - 5xx server errors
+   * - 429 rate limit errors
+   * Does NOT retry 4xx errors (except 429)
+   */
+  isRetryableStatus(status) {
+    if (status === 429) {
+      return true;
+    }
+    if (status >= 500 && status < 600) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Check if an error is retryable (network errors, timeouts)
+   */
+  isRetryableError(error) {
+    if (error.name === "AbortError") {
+      return true;
+    }
+    if (error instanceof TypeError) {
+      return true;
+    }
+    if (error.message.includes("fetch failed") || error.message.includes("network") || error.message.includes("ECONNREFUSED") || error.message.includes("ENOTFOUND") || error.message.includes("ETIMEDOUT")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Calculate delay with exponential backoff and jitter
+   */
+  calculateDelay(attempt, retryConfig) {
+    const exponentialDelay = retryConfig.initialDelayMs * Math.pow(retryConfig.backoffMultiplier, attempt);
+    const cappedDelay = Math.min(exponentialDelay, retryConfig.maxDelayMs);
+    const jitter = cappedDelay * retryConfig.jitterFactor * Math.random();
+    return Math.floor(cappedDelay + jitter);
+  }
+  /**
+   * Sleep for a given number of milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get default retry configuration
+   */
+  getRetryConfig(options) {
+    if (options === false) {
+      return null;
+    }
+    return {
+      maxRetries: options?.maxRetries ?? RETRY_CONFIG.MAX_RETRIES,
+      initialDelayMs: options?.initialDelayMs ?? RETRY_CONFIG.INITIAL_DELAY_MS,
+      maxDelayMs: options?.maxDelayMs ?? RETRY_CONFIG.MAX_DELAY_MS,
+      backoffMultiplier: options?.backoffMultiplier ?? RETRY_CONFIG.BACKOFF_MULTIPLIER,
+      jitterFactor: options?.jitterFactor ?? RETRY_CONFIG.JITTER_FACTOR
+    };
+  }
+  /**
+   * Make an HTTP request with validation and automatic retry
+   */
+  async request(options, responseSchema) {
+    let url = `${this.config.baseUrl}${options.endpoint}`;
+    if (options.params) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== void 0) {
+          searchParams.append(key, String(value));
+        }
+      }
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    const timeout = options.timeout ?? this.config.timeout;
+    const retryConfig = this.getRetryConfig(options.retry);
+    const startTime = Date.now();
+    let attempt = 0;
+    const maxAttempts = retryConfig ? retryConfig.maxRetries + 1 : 1;
+    while (attempt < maxAttempts) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const signal = options.signal ? this.mergeSignals(options.signal, controller.signal) : controller.signal;
+      try {
+        const headers = this.buildHeaders(options);
+        const body = options.body ? JSON.stringify(options.body) : null;
+        if (this.config.debug) {
+          console.log(`[Beeper SDK] Request:`, {
+            method: options.method,
+            url,
+            headers: this.sanitizeHeaders(headers),
+            body: options.body,
+            attempt: attempt + 1,
+            maxAttempts
+          });
+        }
+        const requestInit = {
+          method: options.method,
+          headers,
+          signal
+        };
+        if (body !== null) {
+          requestInit.body = body;
+        }
+        const response = await this.config.fetch(url, requestInit);
+        clearTimeout(timeoutId);
+        const requestId = response.headers.get(HEADERS.REQUEST_ID) ?? void 0;
+        if (this.config.debug) {
+          console.log(`[Beeper SDK] Response:`, {
+            url,
+            status: response.status,
+            statusText: response.statusText,
+            requestId,
+            attempt: attempt + 1,
+            timeMs: Date.now() - startTime
+          });
+        }
+        if (!response.ok) {
+          const errorBody = await this.safeParseJson(response);
+          if (retryConfig && this.isRetryableStatus(response.status) && attempt < retryConfig.maxRetries) {
+            const delay = this.calculateDelay(attempt, retryConfig);
+            if (this.config.debug) {
+              console.log(`[Beeper SDK] Retrying:`, {
+                url,
+                status: response.status,
+                attempt: attempt + 1,
+                maxRetries: retryConfig.maxRetries,
+                delayMs: delay
+              });
+            }
+            await this.sleep(delay);
+            attempt++;
+            continue;
+          }
+          throw BeeperError.fromHttpResponse(
+            response.status,
+            errorBody,
+            requestId
+          );
+        }
+        const data = await this.safeParseJson(response);
+        if (responseSchema) {
+          const result = responseSchema.safeParse(data);
+          if (!result.success) {
+            throw BeeperError.validation("Invalid response from server", {
+              zodErrors: result.error.errors
+            });
+          }
+          return {
+            data: result.data,
+            status: response.status,
+            headers: response.headers,
+            requestId,
+            retryCount: attempt,
+            totalTimeMs: Date.now() - startTime
+          };
+        }
+        return {
+          data,
+          status: response.status,
+          headers: response.headers,
+          requestId,
+          retryCount: attempt,
+          totalTimeMs: Date.now() - startTime
+        };
+      } catch (error) {
+        clearTimeout(timeoutId);
+        const isErrorInstance = error instanceof Error;
+        const shouldRetry = retryConfig && isErrorInstance && this.isRetryableError(error) && attempt < retryConfig.maxRetries;
+        if (shouldRetry) {
+          const delay = this.calculateDelay(attempt, retryConfig);
+          if (this.config.debug) {
+            console.log(`[Beeper SDK] Retrying after error:`, {
+              url,
+              error: isErrorInstance ? error.message : "Unknown error",
+              attempt: attempt + 1,
+              maxRetries: retryConfig.maxRetries,
+              delayMs: delay
+            });
+          }
+          await this.sleep(delay);
+          attempt++;
+          continue;
+        }
+        if (isErrorInstance && error.name === "AbortError") {
+          throw BeeperError.timeout(options.endpoint, timeout);
+        }
+        if (error instanceof TypeError) {
+          throw BeeperError.networkError(
+            `Network error: ${error.message}`,
+            error
+          );
+        }
+        if (error instanceof BeeperError) {
+          throw error;
+        }
+        const errorOptions = {
+          code: ErrorCodes.UNKNOWN_ERROR,
+          message: isErrorInstance ? error.message : "Unknown error"
+        };
+        if (isErrorInstance) {
+          errorOptions.cause = error;
+        }
+        throw new BeeperError(errorOptions);
+      }
+    }
+    throw BeeperError.networkError(
+      `Max retries (${retryConfig?.maxRetries ?? 0}) exceeded for ${options.endpoint}`
+    );
+  }
+  /**
+   * GET request helper
+   */
+  async get(endpoint, options, schema) {
+    return this.request({ ...options, method: "GET", endpoint }, schema);
+  }
+  /**
+   * POST request helper
+   */
+  async post(endpoint, body, options, schema) {
+    return this.request(
+      { ...options, method: "POST", endpoint, body },
+      schema
+    );
+  }
+  /**
+   * PUT request helper
+   */
+  async put(endpoint, body, options, schema) {
+    return this.request(
+      { ...options, method: "PUT", endpoint, body },
+      schema
+    );
+  }
+  /**
+   * PATCH request helper
+   */
+  async patch(endpoint, body, options, schema) {
+    return this.request(
+      { ...options, method: "PATCH", endpoint, body },
+      schema
+    );
+  }
+  /**
+   * DELETE request helper
+   */
+  async delete(endpoint, options, schema) {
+    return this.request({ ...options, method: "DELETE", endpoint }, schema);
+  }
+  /**
+   * Build request headers
+   */
+  buildHeaders(options) {
+    const headers = {
+      [HEADERS.CONTENT_TYPE]: "application/json",
+      [HEADERS.AUTHORIZATION]: `Bearer ${this.config.apiKey}`,
+      "User-Agent": `beeper-sdk/${SDK_VERSION}`,
+      ...options.headers
+    };
+    if (options.idempotencyKey) {
+      headers[HEADERS.IDEMPOTENCY_KEY] = options.idempotencyKey;
+    }
+    return headers;
+  }
+  /**
+   * Sanitize headers for logging (redact sensitive values)
+   */
+  sanitizeHeaders(headers) {
+    const sensitiveKeys = [
+      "authorization",
+      "x-api-key",
+      "cookie",
+      "set-cookie",
+      "x-auth-token"
+    ];
+    const sanitized = {};
+    for (const [key, value] of Object.entries(headers)) {
+      if (sensitiveKeys.includes(key.toLowerCase())) {
+        sanitized[key] = "[REDACTED]";
+      } else {
+        sanitized[key] = value;
+      }
+    }
+    return sanitized;
+  }
+  /**
+   * Safely parse JSON response
+   */
+  async safeParseJson(response) {
+    const text = await response.text();
+    if (!text) {
+      return null;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  /**
+   * Merge two abort signals
+   */
+  mergeSignals(signal1, signal2) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal1.addEventListener("abort", abort);
+    signal2.addEventListener("abort", abort);
+    if (signal1.aborted || signal2.aborted) {
+      controller.abort();
+    }
+    return controller.signal;
+  }
+};
+function generateIdempotencyKey() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 15);
+  return `${timestamp}-${random}`;
+}
+
+// src/client/filters.schema.ts
+var FILTER_SCHEMA = [
+  {
+    name: "Platform & Activity",
+    description: "Filter by platform and user activity",
+    filters: [
+      {
+        name: "platform",
+        description: "Target users on a specific platform",
+        type: "string",
+        enum: ["all", "farcaster", "twitter"],
+        example: "farcaster"
+      },
+      {
+        name: "activeInLastDays",
+        description: "Users who have been active within the last N days",
+        type: "number",
+        min: 1,
+        max: 365,
+        example: 30
+      },
+      {
+        name: "minCastCount",
+        description: "Users with at least N posts/casts",
+        type: "number",
+        min: 0,
+        example: 10
+      }
+    ]
+  },
+  {
+    name: "Reputation & Quality",
+    description: "Filter by user reputation scores",
+    filters: [
+      {
+        name: "neynarScoreMin",
+        description: "Minimum Neynar reputation score (0-1, higher = more reputable)",
+        type: "number",
+        min: 0,
+        max: 1,
+        example: 0.5
+      },
+      {
+        name: "neynarScoreMax",
+        description: "Maximum Neynar reputation score",
+        type: "number",
+        min: 0,
+        max: 1,
+        example: 0.9
+      },
+      {
+        name: "quotientScoreMin",
+        description: "Minimum Quotient score (0-1, engagement quality)",
+        type: "number",
+        min: 0,
+        max: 1,
+        example: 0.5
+      },
+      {
+        name: "spamLabel",
+        description: "Filter by spam classification",
+        type: "string",
+        enum: ["not_spam_only", "spam_only", "all"],
+        example: "not_spam_only"
+      },
+      {
+        name: "verifiedOnly",
+        description: "Only include verified users",
+        type: "boolean",
+        example: true
+      }
+    ]
+  },
+  {
+    name: "Social Graph",
+    description: "Filter by follower counts and relationships",
+    filters: [
+      {
+        name: "minFollowers",
+        description: "Minimum follower count",
+        type: "number",
+        min: 0,
+        example: 1e3
+      },
+      {
+        name: "maxFollowers",
+        description: "Maximum follower count",
+        type: "number",
+        min: 0,
+        example: 1e5
+      },
+      {
+        name: "followersOf",
+        description: "Users who follow a specific FID (Farcaster ID)",
+        type: "number",
+        example: 3
+      },
+      {
+        name: "mutualsWith",
+        description: "Users who have mutual follows with a specific FID",
+        type: "number",
+        example: 3
+      }
+    ]
+  },
+  {
+    name: "Token Filters",
+    description: "Filter by token preferences or holdings. IMPORTANT: Signal tokens and token holders are different concepts.",
+    filters: [
+      {
+        name: "signalTokens",
+        description: 'Users who have SET specific tokens on their profile as interests/preferences. Does NOT require actually holding the token - it is a social signal like "I am interested in this community". Use this to find community members by affinity.',
+        type: "array",
+        items: { name: "tokenAddress", type: "string", description: "Token contract address", example: "0x..." },
+        example: ["0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed"]
+      },
+      {
+        name: "tokenHolders",
+        description: "Users who actually HOLD specific tokens in their wallet (verified onchain). Use this to find real token holders with actual balances. Requires wallet verification.",
+        type: "array",
+        items: {
+          name: "tokenConfig",
+          type: "object",
+          description: "Token holder filter config",
+          example: { tokenAddress: "0x...", chainId: 8453 },
+          properties: {
+            tokenAddress: { name: "tokenAddress", type: "string", description: "Token contract address", example: "0x..." },
+            chainId: { name: "chainId", type: "number", description: "Chain ID (1=Ethereum, 8453=Base)", example: 8453 },
+            minBalance: { name: "minBalance", type: "string", description: "Minimum balance in wei (e.g., 1000000000000000000 = 1 token with 18 decimals)", example: "1000000000000000000" }
+          }
+        },
+        example: [{ tokenAddress: "0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed", chainId: 8453 }]
+      },
+      {
+        name: "hasBaseWallet",
+        description: "Users with a wallet on Base chain",
+        type: "boolean",
+        example: true
+      },
+      {
+        name: "hasVerifiedWallet",
+        description: "Users with a verified wallet address",
+        type: "boolean",
+        example: true
+      }
+    ]
+  },
+  {
+    name: "Economics",
+    description: "Filter by attention price and battery",
+    filters: [
+      {
+        name: "maxAttentionPriceUsd",
+        description: "Maximum attention price in USD",
+        type: "number",
+        min: 0,
+        example: 0.5
+      },
+      {
+        name: "minBatteryPercentage",
+        description: "Minimum battery percentage (0-100)",
+        type: "number",
+        min: 0,
+        max: 100,
+        example: 50
+      },
+      {
+        name: "hasRechargedInLastDays",
+        description: "Users who recharged battery within N days",
+        type: "number",
+        min: 1,
+        example: 7
+      },
+      {
+        name: "excludePingedToday",
+        description: "Exclude users who were already pinged today",
+        type: "boolean",
+        example: true
+      }
+    ]
+  },
+  {
+    name: "Geography",
+    description: "Filter by location and timezone",
+    filters: [
+      {
+        name: "countries",
+        description: "ISO 3166-1 alpha-2 country codes",
+        type: "array",
+        items: { name: "countryCode", type: "string", description: "Country code", example: "US" },
+        example: ["US", "CA", "GB"]
+      },
+      {
+        name: "timezones",
+        description: "Filter by UTC timezone offset",
+        type: "array",
+        items: {
+          name: "timezone",
+          type: "object",
+          description: "Timezone configuration",
+          example: { offset: -5, range: 2 },
+          properties: {
+            offset: { name: "offset", type: "number", description: "UTC offset in hours", example: -5 },
+            range: { name: "range", type: "number", description: "Range in hours for fuzzy matching", example: 2 }
+          }
+        },
+        example: [{ offset: -5, range: 2 }]
+      }
+    ]
+  },
+  {
+    name: "User Selection",
+    description: "Target specific users",
+    filters: [
+      {
+        name: "fids",
+        description: "Specific Farcaster IDs to target",
+        type: "array",
+        items: { name: "fid", type: "number", description: "Farcaster ID", example: 3 },
+        example: [3, 1234, 5678]
+      },
+      {
+        name: "userIds",
+        description: "Specific user IDs to target",
+        type: "array",
+        items: { name: "userId", type: "string", description: "User ID", example: "abc123" },
+        example: ["abc123", "def456"]
+      }
+    ]
+  },
+  {
+    name: "Sorting",
+    description: "Order results",
+    filters: [
+      {
+        name: "orderBy",
+        description: "Sort order for results",
+        type: "string",
+        enum: [
+          "attention_price_asc",
+          "attention_price_desc",
+          "neynar_score_desc",
+          "followers_desc",
+          "followers_asc",
+          "recent_activity",
+          "battery_desc",
+          "random"
+        ],
+        example: "attention_price_asc"
+      }
+    ]
+  }
+];
+function getAllFilterNames() {
+  return FILTER_SCHEMA.flatMap((cat) => cat.filters.map((f) => f.name));
+}
+function getFilterSchema(name) {
+  for (const category of FILTER_SCHEMA) {
+    const filter = category.filters.find((f) => f.name === name);
+    if (filter) return filter;
+  }
+  return void 0;
+}
+function generateFilterDocumentation() {
+  let doc = "# Available Filters\n\n";
+  for (const category of FILTER_SCHEMA) {
+    doc += `## ${category.name}
+`;
+    doc += `${category.description}
+
+`;
+    for (const filter of category.filters) {
+      doc += `### \`${filter.name}\`
+`;
+      doc += `${filter.description}
+`;
+      doc += `- Type: \`${filter.type}\`
+`;
+      if (filter.enum) {
+        doc += `- Values: ${filter.enum.map((v) => `\`${v}\``).join(", ")}
+`;
+      }
+      if (filter.min !== void 0) doc += `- Min: ${filter.min}
+`;
+      if (filter.max !== void 0) doc += `- Max: ${filter.max}
+`;
+      doc += `- Example: \`${JSON.stringify(filter.example)}\`
+
+`;
+    }
+  }
+  return doc;
+}
+
+// src/client/AgentClient.ts
+var ENDPOINTS2 = {
+  LOOKUP: "/agent/lookup",
+  INTENT: "/agent/intent",
+  PRICE: "/agent/price",
+  ESTIMATE: "/agent/estimate",
+  PREVIEW: "/agent/preview",
+  BULK_INTENT: "/agent/bulk-intent"
+};
+var AgentClient = class {
+  http;
+  // @ts-expect-error Reserved for future use
+  _debug;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw BeeperError.validation("API key is required");
+    }
+    const httpConfig = createHttpConfig({
+      apiKey: config.apiKey,
+      ...config.environment && { environment: config.environment },
+      ...config.baseUrl && { baseUrl: config.baseUrl },
+      ...config.timeoutMs && { timeout: config.timeoutMs },
+      ...config.fetch && { fetch: config.fetch },
+      ...config.debug && { debug: config.debug }
+    });
+    this.http = new HttpClient(httpConfig);
+    this._debug = config.debug ?? false;
+  }
+  /**
+   * 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"
+   * ```
+   */
+  async lookup(identifier) {
+    const params = typeof identifier === "number" ? { fid: identifier } : { q: identifier };
+    const response = await this.http.get(
+      ENDPOINTS2.LOOKUP,
+      { params }
+    );
+    return response.data.data;
+  }
+  /**
+   * 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}`);
+   * ```
+   */
+  async getPrice(identifier) {
+    const params = typeof identifier === "number" ? { fid: identifier } : { q: identifier };
+    const response = await this.http.get(
+      ENDPOINTS2.PRICE,
+      { params }
+    );
+    return response.data.data;
+  }
+  /**
+   * 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"
+   * ```
+   */
+  async createIntent(input) {
+    const amountStr = input.amount.replace(/^\$/, "").trim();
+    const amountNum = parseFloat(amountStr);
+    if (isNaN(amountNum) || amountNum <= 0) {
+      throw BeeperError.validation("Amount must be a positive number");
+    }
+    const response = await this.http.post(
+      ENDPOINTS2.INTENT,
+      {
+        to: input.to,
+        amountUsd: amountStr,
+        message: input.message,
+        chainId: input.chainId ?? 8453,
+        // Default to Base
+        tokenSymbol: input.tokenSymbol ?? "USDC"
+      }
+    );
+    return response.data.data;
+  }
+  /**
+   * 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)"
+   * ```
+   */
+  async getPaymentInstruction(input) {
+    const intent = await this.createIntent(input);
+    return intent.instruction;
+  }
+  /**
+   * 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}`);
+   * ```
+   */
+  async estimate(input) {
+    const budgetStr = input.budget.replace(/^\$/, "").trim();
+    const budgetNum = parseFloat(budgetStr);
+    if (isNaN(budgetNum) || budgetNum <= 0) {
+      throw BeeperError.validation("Budget must be a positive number");
+    }
+    const response = await this.http.post(
+      ENDPOINTS2.ESTIMATE,
+      {
+        filters: input.filters,
+        budgetUsd: budgetStr,
+        message: input.message
+      }
+    );
+    return response.data.data;
+  }
+  /**
+   * 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}`);
+   * });
+   * ```
+   */
+  async preview(input) {
+    const limit = Math.min(input.limit ?? 10, 20);
+    const response = await this.http.post(
+      ENDPOINTS2.PREVIEW,
+      {
+        filters: input.filters,
+        limit
+      }
+    );
+    return response.data.data;
+  }
+  /**
+   * 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"
+   * ```
+   */
+  async createBulkIntent(input) {
+    const budgetStr = input.budget.replace(/^\$/, "").trim();
+    const budgetNum = parseFloat(budgetStr);
+    if (isNaN(budgetNum) || budgetNum <= 0) {
+      throw BeeperError.validation("Budget must be a positive number");
+    }
+    const response = await this.http.post(
+      ENDPOINTS2.BULK_INTENT,
+      {
+        filters: input.filters,
+        budgetUsd: budgetStr,
+        message: input.message,
+        chainId: input.chainId ?? 8453
+      }
+    );
+    return response.data.data;
+  }
+  /**
+   * 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() {
+    return FILTER_SCHEMA;
+  }
+  /**
+   * 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() {
+    return generateFilterDocumentation();
+  }
+};
+
+// src/client/auth.ts
+var API_KEY_PREFIXES = {
+  LIVE: "bpk_live_",
+  TEST: "bpk_test_"
+};
+function isValidApiKeyFormat(apiKey) {
+  if (!apiKey || typeof apiKey !== "string") {
+    return false;
+  }
+  const hasValidPrefix = apiKey.startsWith(API_KEY_PREFIXES.LIVE) || apiKey.startsWith(API_KEY_PREFIXES.TEST);
+  if (!hasValidPrefix) {
+    return false;
+  }
+  const minLength = API_KEY_PREFIXES.LIVE.length + 20;
+  return apiKey.length >= minLength;
+}
+function getApiKeyEnvironment(apiKey) {
+  if (!apiKey || typeof apiKey !== "string") {
+    return null;
+  }
+  if (apiKey.startsWith(API_KEY_PREFIXES.LIVE)) {
+    return "production";
+  }
+  if (apiKey.startsWith(API_KEY_PREFIXES.TEST)) {
+    return "test";
+  }
+  return null;
+}
+function createAuthorizationHeader(apiKey) {
+  return `Bearer ${apiKey}`;
+}
+function maskApiKey(apiKey) {
+  if (!apiKey || apiKey.length < 12) {
+    return "***";
+  }
+  const prefix = apiKey.startsWith(API_KEY_PREFIXES.LIVE) ? API_KEY_PREFIXES.LIVE : apiKey.startsWith(API_KEY_PREFIXES.TEST) ? API_KEY_PREFIXES.TEST : "";
+  const suffix = apiKey.slice(-4);
+  return `${prefix}***${suffix}`;
+}
+
+// src/client/BeeperClient.ts
+var QuoteSchema = z.object({
+  id: z.string(),
+  status: z.enum([
+    "pending",
+    "deposit_confirmed",
+    "executing",
+    "completed",
+    "expired",
+    "failed"
+  ]),
+  recipientCount: z.number(),
+  totalAmount: z.string(),
+  protocolFee: z.string(),
+  depositAmount: z.string(),
+  depositAddress: z.string(),
+  depositChainId: z.number(),
+  depositTokenAddress: z.string(),
+  expiresAt: z.string(),
+  input: z.object({
+    filter: z.record(z.unknown()),
+    tokenAddress: z.string(),
+    chainId: z.number(),
+    amountPerRecipient: z.string(),
+    budgetCap: z.string(),
+    memo: z.string().optional(),
+    metadata: z.record(z.unknown()).optional()
+  }),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var AttentionQuoteSchema = z.object({
+  id: z.string(),
+  status: z.enum([
+    "pending",
+    "deposit_confirmed",
+    "executing",
+    "completed",
+    "expired",
+    "failed"
+  ]),
+  recipientCount: z.number(),
+  expiresAt: z.string(),
+  input: z.record(z.unknown()),
+  createdAt: z.string(),
+  updatedAt: z.string()
+}).passthrough();
+var ConfirmResultSchema = z.object({
+  quoteId: z.string(),
+  status: z.enum(["confirmed", "pending_verification"]),
+  detectedAmount: z.string(),
+  sufficient: z.boolean(),
+  blockNumber: z.number(),
+  confirmedAt: z.string()
+});
+var ExecuteResultSchema = z.object({
+  quoteId: z.string(),
+  status: z.enum(["executing", "queued"]),
+  estimatedCompletionAt: z.string(),
+  batchId: z.string()
+});
+var ReceiptSchema = z.object({
+  quoteId: z.string(),
+  status: z.enum(["completed", "partial", "failed"]),
+  successCount: z.number(),
+  failureCount: z.number(),
+  totalSent: z.string(),
+  refundAmount: z.string(),
+  refundTxHash: z.string().optional(),
+  transactions: z.array(
+    z.object({
+      recipient: z.string(),
+      amount: z.string(),
+      txHash: z.string().nullable(),
+      status: z.enum(["success", "failed"]),
+      error: z.string().optional()
+    })
+  ),
+  completedAt: z.string()
+});
+var HealthSchema = z.object({
+  status: z.enum(["healthy", "degraded", "unhealthy"]),
+  version: z.string(),
+  timestamp: z.string(),
+  services: z.object({
+    database: z.enum(["up", "down"]),
+    queue: z.enum(["up", "down"]),
+    oracle: z.enum(["up", "down"])
+  })
+});
+var ENDPOINTS3 = {
+  QUOTES: "/api/v1/sdk/send/quotes",
+  HEALTH: "/api/v1/sdk/send/health"
+};
+var BeeperClient = class {
+  http;
+  constructor(config) {
+    this.validateConfig(config);
+    const httpConfig = createHttpConfig({
+      apiKey: config.apiKey,
+      ...config.environment !== void 0 && { environment: config.environment },
+      ...config.baseUrl !== void 0 && { baseUrl: config.baseUrl },
+      ...config.timeoutMs !== void 0 && { timeout: config.timeoutMs },
+      ...config.fetch !== void 0 && { fetch: config.fetch },
+      ...config.debug !== void 0 && { debug: config.debug }
+    });
+    this.http = new HttpClient(httpConfig);
+  }
+  /**
+   * Validates client configuration
+   */
+  validateConfig(config) {
+    if (!config.apiKey) {
+      throw BeeperError.validation("API key is required");
+    }
+    if (!isValidApiKeyFormat(config.apiKey)) {
+      throw BeeperError.validation(
+        "Invalid API key format. Key must start with bpk_live_ or bpk_test_"
+      );
+    }
+  }
+  /**
+   * 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) {
+    this.validateDraftInput(input);
+    return {
+      id: `draft_${generateIdempotencyKey()}`,
+      input,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Validates draft input parameters
+   */
+  validateDraftInput(input) {
+    if (!input.filter || typeof input.filter !== "object") {
+      throw BeeperError.validation("Filter is required and must be an object");
+    }
+    if (!input.tokenAddress || !/^0x[a-fA-F0-9]{40}$/.test(input.tokenAddress)) {
+      throw BeeperError.validation("Invalid token address format");
+    }
+    if (!input.chainId || typeof input.chainId !== "number") {
+      throw BeeperError.validation("Chain ID is required and must be a number");
+    }
+    if (!input.amountPerRecipient || !/^[0-9]+$/.test(input.amountPerRecipient)) {
+      throw BeeperError.validation(
+        "Amount per recipient must be a positive integer string"
+      );
+    }
+    if (!input.budgetCap || !/^[0-9]+$/.test(input.budgetCap)) {
+      throw BeeperError.validation("Budget cap must be a positive integer string");
+    }
+    if (input.memo !== void 0 && input.memo.length > 256) {
+      throw BeeperError.validation("Memo must be 256 characters or less");
+    }
+  }
+  /**
+   * 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
+   */
+  async createQuote(draft, opts) {
+    const body = {
+      ...draft.input,
+      ttlSeconds: opts?.ttlSeconds ?? 300
+    };
+    const response = await this.http.post(
+      ENDPOINTS3.QUOTES,
+      body,
+      {},
+      QuoteSchema
+    );
+    return response.data;
+  }
+  /**
+   * 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',
+   * });
+   * ```
+   */
+  async createAttentionQuote(input, opts) {
+    if (!input.message || input.message.length === 0) {
+      throw BeeperError.validation("Message is required");
+    }
+    if (input.message.length > 1e3) {
+      throw BeeperError.validation("Message must be 1000 characters or less");
+    }
+    if (!input.recipientFids?.length && !input.filter) {
+      throw BeeperError.validation("Must provide either recipientFids or filter");
+    }
+    if (input.recipientFids && input.recipientFids.length > 1e3) {
+      throw BeeperError.validation("recipientFids cannot exceed 1000");
+    }
+    if (!input.budgetUSD || !/^[0-9]+\.?[0-9]*$/.test(input.budgetUSD)) {
+      throw BeeperError.validation("budgetUSD must be a valid USD amount");
+    }
+    if (parseFloat(input.budgetUSD) <= 0) {
+      throw BeeperError.validation("budgetUSD must be positive");
+    }
+    const body = {
+      message: input.message,
+      recipientFids: input.recipientFids,
+      filter: input.filter,
+      budgetUSD: input.budgetUSD,
+      rewardType: input.rewardType ?? "guaranteed",
+      memo: input.memo,
+      metadata: input.metadata,
+      ttlSeconds: opts?.ttlSeconds ?? 300
+    };
+    const response = await this.http.post(
+      ENDPOINTS3.QUOTES,
+      body,
+      {},
+      AttentionQuoteSchema
+    );
+    return response.data;
+  }
+  /**
+   * Retrieves an existing quote by ID
+   * @param quoteId - The quote ID
+   * @returns The quote
+   */
+  async getQuote(quoteId) {
+    const response = await this.http.get(
+      `${ENDPOINTS3.QUOTES}/${quoteId}`,
+      {},
+      QuoteSchema
+    );
+    return response.data;
+  }
+  /**
+   * Confirms that deposit has been made
+   * @param quoteId - The quote ID
+   * @param params - Confirmation parameters including txHash and idempotencyKey
+   * @returns Confirmation result
+   */
+  async confirmDeposit(quoteId, params) {
+    if (!params.idempotencyKey) {
+      throw BeeperError.validation("Idempotency key is required for confirmDeposit");
+    }
+    if (!params.txHash || !/^0x[a-fA-F0-9]{64}$/.test(params.txHash)) {
+      throw BeeperError.validation("Invalid transaction hash format");
+    }
+    const response = await this.http.post(
+      `${ENDPOINTS3.QUOTES}/${quoteId}/confirm`,
+      { txHash: params.txHash },
+      { idempotencyKey: params.idempotencyKey },
+      ConfirmResultSchema
+    );
+    return response.data;
+  }
+  /**
+   * Triggers execution of the send
+   * @param quoteId - The quote ID
+   * @param params - Execution parameters including idempotencyKey
+   * @returns Execution result
+   */
+  async executeSend(quoteId, params) {
+    if (!params.idempotencyKey) {
+      throw BeeperError.validation("Idempotency key is required for executeSend");
+    }
+    const response = await this.http.post(
+      `${ENDPOINTS3.QUOTES}/${quoteId}/execute`,
+      {},
+      { idempotencyKey: params.idempotencyKey },
+      ExecuteResultSchema
+    );
+    return response.data;
+  }
+  /**
+   * Gets the receipt for a completed (or failed) execution
+   * @param quoteId - The quote ID
+   * @returns The receipt
+   */
+  async getReceiptByQuoteId(quoteId) {
+    const response = await this.http.get(
+      `${ENDPOINTS3.QUOTES}/${quoteId}/receipt`,
+      {},
+      ReceiptSchema
+    );
+    return response.data;
+  }
+  /**
+   * Polls until execution completes, then returns receipt
+   * @param quoteId - The quote ID
+   * @param opts - Polling options
+   * @returns The receipt when execution completes
+   */
+  async pollUntilCompleteByQuoteId(quoteId, opts) {
+    const maxAttempts = opts?.maxAttempts ?? 60;
+    const intervalMs = opts?.intervalMs ?? 2e3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const quote = await this.getQuote(quoteId);
+      if (opts?.onPoll) {
+        opts.onPoll(quote);
+      }
+      if (quote.status === "completed" || quote.status === "failed") {
+        return this.getReceiptByQuoteId(quoteId);
+      }
+      if (quote.status === "expired") {
+        throw new BeeperError({
+          code: ErrorCodes.QUOTE_EXPIRED,
+          message: `Quote ${quoteId} expired while polling`,
+          retryable: false
+        });
+      }
+      if (attempt < maxAttempts - 1) {
+        await this.sleep(intervalMs);
+      }
+    }
+    throw new BeeperError({
+      code: ErrorCodes.TIMEOUT,
+      message: `Polling timed out after ${maxAttempts} attempts`,
+      retryable: false
+    });
+  }
+  /**
+   * Checks API health status
+   * @returns Health status
+   */
+  async health() {
+    const response = await this.http.get(
+      ENDPOINTS3.HEALTH,
+      {},
+      HealthSchema
+    );
+    return response.data;
+  }
+  /**
+   * Sleep helper for polling
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var BeeperClient_default = BeeperClient;
+var LegacyFilterOperatorSchema = z.enum([
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "nin",
+  "contains",
+  "startsWith",
+  "endsWith"
+]);
+var LegacyFilterValueSchema = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.array(z.string()),
+  z.array(z.number())
+]);
+var LegacyFieldComparisonSchema = z.object({
+  field: z.string().min(1),
+  op: LegacyFilterOperatorSchema,
+  value: LegacyFilterValueSchema
+});
+var LegacyRecipientFilterDSLSchema = z.lazy(
+  () => z.union([
+    // Match all
+    z.object({ all: z.literal(true) }),
+    // Logical AND
+    z.object({ and: z.array(LegacyRecipientFilterDSLSchema).min(1) }),
+    // Logical OR
+    z.object({ or: z.array(LegacyRecipientFilterDSLSchema).min(1) }),
+    // Logical NOT
+    z.object({ not: LegacyRecipientFilterDSLSchema }),
+    // Field comparison
+    LegacyFieldComparisonSchema
+  ])
+);
+var FilterOperatorSchema = LegacyFilterOperatorSchema;
+var FilterValueSchema = LegacyFilterValueSchema;
+var FieldComparisonSchema = LegacyFieldComparisonSchema;
+var PlatformFilterSchema = z.object({
+  platform: z.enum(["all", "farcaster", "twitter"])
+});
+var SpecificUsersFilterSchema = z.object({
+  specificIds: z.array(z.string()).optional(),
+  specificFids: z.array(z.number().int()).optional(),
+  specificUsernames: z.array(z.string()).optional(),
+  specificUsersMode: z.enum(["exclusive", "additive"]).optional()
+});
+var ExcludeUsersFilterSchema = z.object({
+  excludeFids: z.array(z.number().int()).optional(),
+  excludeUsernames: z.array(z.string()).optional()
+});
+var MinFollowersFilterSchema = z.object({
+  minFollowers: z.number().int().min(0)
+});
+var MaxFollowersFilterSchema = z.object({
+  maxFollowers: z.number().int().min(0)
+});
+var MinFollowingFilterSchema = z.object({
+  minFollowing: z.number().int().min(0)
+});
+var MaxFollowingFilterSchema = z.object({
+  maxFollowing: z.number().int().min(0)
+});
+var FollowersOfFilterSchema = z.object({
+  followersOf: z.number().int()
+});
+var FollowingOfFilterSchema = z.object({
+  followingOf: z.number().int()
+});
+var MutualsWithFilterSchema = z.object({
+  mutualsWith: z.number().int()
+});
+var SignalTokenFilterSchema = z.object({
+  signalTokens: z.array(
+    z.object({
+      tokenAddress: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid token address")
+    })
+  )
+});
+var TimezoneFilterSchema = z.object({
+  timezones: z.array(
+    z.object({
+      offset: z.number(),
+      // UTC offset in hours (e.g., -5, +9, +5.5)
+      range: z.number().min(0).max(12).optional()
+      // Range in hours (+/-)
+    })
+  )
+});
+var CountryFilterSchema = z.object({
+  countries: z.array(
+    z.object({
+      code: z.string().length(2)
+      // ISO 3166-1 alpha-2 country code
+    })
+  )
+});
+var RolesFilterSchema = z.object({
+  roles: z.array(z.string())
+});
+var SocialFilterSchema = z.object({
+  specificIds: z.array(z.string()).optional(),
+  specificFids: z.array(z.number().int()).optional(),
+  specificUsernames: z.array(z.string()).optional(),
+  specificUsersMode: z.enum(["exclusive", "additive"]).optional(),
+  excludeFids: z.array(z.number().int()).optional(),
+  excludeUsernames: z.array(z.string()).optional(),
+  followersOf: z.number().int().optional(),
+  followingOf: z.number().int().optional(),
+  mutualsWith: z.number().int().optional(),
+  minFollowers: z.number().int().min(0).optional(),
+  maxFollowers: z.number().int().min(0).optional(),
+  minFollowing: z.number().int().min(0).optional(),
+  maxFollowing: z.number().int().min(0).optional(),
+  signalTokens: z.array(
+    z.object({
+      tokenAddress: z.string()
+    })
+  ).optional(),
+  timezones: z.array(
+    z.object({
+      offset: z.number(),
+      range: z.number().min(0).max(12).optional()
+    })
+  ).optional(),
+  countries: z.array(
+    z.object({
+      code: z.string()
+    })
+  ).optional(),
+  roles: z.array(z.string()).optional()
+});
+var ActiveInLastDaysFilterSchema = z.object({
+  activeInLastDays: z.number().int().min(1).max(365)
+});
+var NeynarScoreMinFilterSchema = z.object({
+  neynarScoreMin: z.number().min(0).max(1)
+});
+var NeynarScoreMaxFilterSchema = z.object({
+  neynarScoreMax: z.number().min(0).max(1)
+});
+var QuotientScoreMinFilterSchema = z.object({
+  quotientScoreMin: z.number().min(0).max(1)
+});
+var QuotientScoreMaxFilterSchema = z.object({
+  quotientScoreMax: z.number().min(0).max(1)
+});
+var SpamLabelFilterSchema = z.object({
+  spamLabel: z.enum(["not_spam_only", "spam_only", "all"])
+});
+var ProSubscriptionFilterSchema = z.object({
+  proSubscriptionRequired: z.boolean()
+});
+var MinProTenureDaysFilterSchema = z.object({
+  minProTenureDays: z.number().int().min(0)
+});
+var MinTenureDaysFilterSchema = z.object({
+  minTenureDays: z.number().int().min(0)
+});
+var VerifiedOnlyFilterSchema = z.object({
+  verifiedOnly: z.boolean()
+});
+var ReputationFilterSchema = z.object({
+  neynarScoreMin: z.number().min(0).max(1).optional(),
+  neynarScoreMax: z.number().min(0).max(1).optional(),
+  quotientScoreMin: z.number().min(0).max(1).optional(),
+  quotientScoreMax: z.number().min(0).max(1).optional(),
+  spamLabel: z.enum(["not_spam_only", "spam_only", "all"]).optional(),
+  proSubscriptionRequired: z.boolean().optional(),
+  minProTenureDays: z.number().int().min(0).optional(),
+  minTenureDays: z.number().int().min(0).optional(),
+  verifiedOnly: z.boolean().optional()
+});
+var MaxAttentionPriceFilterSchema = z.object({
+  maxAttentionPriceUsd: z.number().positive()
+});
+var MinAttentionPriceFilterSchema = z.object({
+  minAttentionPriceUsd: z.number().min(0)
+});
+var MinFidFilterSchema = z.object({
+  minFid: z.number().int().min(1)
+});
+var MaxFidFilterSchema = z.object({
+  maxFid: z.number().int().min(1)
+});
+var MinBatteryPercentageFilterSchema = z.object({
+  minBatteryPercentage: z.number().min(0).max(100)
+});
+var ExcludePingedTodayFilterSchema = z.object({
+  excludePingedToday: z.boolean()
+});
+var HasRechargedInLastDaysFilterSchema = z.object({
+  hasRechargedInLastDays: z.number().int().min(1)
+});
+var RequireLotteryOptInFilterSchema = z.object({
+  requireLotteryOptIn: z.boolean()
+});
+var RequireQuizOptInFilterSchema = z.object({
+  requireQuizOptIn: z.boolean()
+});
+var MinCastCountFilterSchema = z.object({
+  minCastCount: z.number().int().min(0)
+});
+var MinClickThroughRateFilterSchema = z.object({
+  minClickThroughRate: z.number().min(0).max(1)
+});
+var IsWaitlistedFilterSchema = z.object({
+  isWaitlisted: z.boolean()
+});
+var HasTierFilterSchema = z.object({
+  hasTier: z.boolean()
+});
+var BeeperEconomicsFilterSchema = z.object({
+  maxAttentionPriceUsd: z.number().min(0).optional(),
+  minAttentionPriceUsd: z.number().min(0).optional(),
+  minFid: z.number().int().min(1).optional(),
+  maxFid: z.number().int().min(1).optional(),
+  minBatteryPercentage: z.number().min(0).max(100).optional(),
+  excludePingedToday: z.boolean().optional(),
+  hasRechargedInLastDays: z.number().int().min(1).optional(),
+  activeInLastDays: z.number().int().min(0).optional(),
+  requireLotteryOptIn: z.boolean().optional(),
+  requireQuizOptIn: z.boolean().optional(),
+  minCastCount: z.number().int().min(0).optional(),
+  minClickThroughRate: z.number().min(0).max(1).optional(),
+  isWaitlisted: z.boolean().optional(),
+  hasTier: z.boolean().optional()
+});
+var TokenHolderFilterSchema = z.object({
+  tokenHolder: z.object({
+    chain: z.enum(["base", "ethereum"]),
+    contractAddress: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid contract address"),
+    tokenStandard: z.enum(["ERC20", "ERC721", "ERC1155"]),
+    tokenId: z.string().optional(),
+    // Required for ERC1155, optional for ERC721
+    minBalance: z.string().optional(),
+    symbol: z.string().optional(),
+    name: z.string().optional()
+  })
+});
+var CachedTokenHolderFilterSchema = z.object({
+  cachedTokenHolder: z.object({
+    chain: z.enum(["base", "ethereum"]),
+    contractAddress: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid contract address"),
+    tokenStandard: z.enum(["ERC20", "ERC721", "ERC1155"]).default("ERC20"),
+    tokenId: z.string().optional(),
+    tokenSymbol: z.string().optional(),
+    tokenName: z.string().optional(),
+    minBalance: z.union([z.string(), z.number()]).optional()
+  })
+});
+var HasBaseWalletFilterSchema = z.object({
+  hasBaseWallet: z.boolean()
+});
+var HasVerifiedWalletFilterSchema = z.object({
+  hasVerifiedWallet: z.boolean()
+});
+var TokenHolderDiscoverySchema = z.object({
+  chain: z.enum(["base", "ethereum"]),
+  contractAddress: z.string(),
+  tokenStandard: z.enum(["ERC20", "ERC721", "ERC1155"]),
+  tokenId: z.string().optional(),
+  minBalance: z.union([z.string(), z.number()]).optional(),
+  symbol: z.string().optional(),
+  name: z.string().optional()
+});
+var CachedTokenHolderSchema = z.object({
+  chain: z.enum(["base", "ethereum"]),
+  contractAddress: z.string(),
+  tokenStandard: z.enum(["ERC20", "ERC721", "ERC1155"]).default("ERC20"),
+  tokenId: z.string().optional(),
+  tokenSymbol: z.string().optional(),
+  tokenName: z.string().optional(),
+  minBalance: z.union([z.string(), z.number()]).optional()
+});
+var OnchainFilterSchema = z.object({
+  hasBaseWallet: z.boolean().optional(),
+  tokenHolders: z.array(TokenHolderDiscoverySchema).optional(),
+  cachedTokenHolders: z.array(CachedTokenHolderSchema).optional(),
+  hasVerifiedWallet: z.boolean().optional()
+});
+var OrderBySchema = z.enum([
+  "attention_price_asc",
+  "attention_price_desc",
+  "neynar_score_desc",
+  "followers_desc",
+  "followers_asc",
+  "recent_activity",
+  "battery_desc",
+  "random"
+]);
+var RecipientFilterSchema = z.object({
+  // Platform filter
+  platform: z.enum(["all", "farcaster", "twitter"]).optional(),
+  // Social targeting
+  social: SocialFilterSchema.optional(),
+  // Reputation filters
+  reputation: ReputationFilterSchema.optional(),
+  // Onchain filters
+  onchain: OnchainFilterSchema.optional(),
+  // Beeper economics filters
+  beeperEconomics: BeeperEconomicsFilterSchema.optional(),
+  // Sorting and limits
+  orderBy: OrderBySchema.optional(),
+  limit: z.number().int().min(1).optional()
+});
+var FilterExpressionSchema = z.lazy(
+  () => z.union([
+    // Match all users
+    z.object({ all: z.literal(true) }),
+    // Logical AND
+    z.object({ and: z.array(FilterExpressionSchema).min(1) }),
+    // Logical OR
+    z.object({ or: z.array(FilterExpressionSchema).min(1) }),
+    // Logical NOT
+    z.object({ not: FilterExpressionSchema }),
+    // Platform filter
+    PlatformFilterSchema,
+    // Activity filter
+    ActiveInLastDaysFilterSchema,
+    // Reputation filters
+    NeynarScoreMinFilterSchema,
+    NeynarScoreMaxFilterSchema,
+    QuotientScoreMinFilterSchema,
+    QuotientScoreMaxFilterSchema,
+    SpamLabelFilterSchema,
+    ProSubscriptionFilterSchema,
+    MinProTenureDaysFilterSchema,
+    MinTenureDaysFilterSchema,
+    VerifiedOnlyFilterSchema,
+    // Social filters
+    MinFollowersFilterSchema,
+    MaxFollowersFilterSchema,
+    MinFollowingFilterSchema,
+    MaxFollowingFilterSchema,
+    FollowersOfFilterSchema,
+    FollowingOfFilterSchema,
+    MutualsWithFilterSchema,
+    // Economics filters
+    MaxAttentionPriceFilterSchema,
+    MinAttentionPriceFilterSchema,
+    MinFidFilterSchema,
+    MaxFidFilterSchema,
+    MinBatteryPercentageFilterSchema,
+    ExcludePingedTodayFilterSchema,
+    HasRechargedInLastDaysFilterSchema,
+    RequireLotteryOptInFilterSchema,
+    RequireQuizOptInFilterSchema,
+    MinCastCountFilterSchema,
+    MinClickThroughRateFilterSchema,
+    IsWaitlistedFilterSchema,
+    HasTierFilterSchema,
+    // Onchain filters
+    TokenHolderFilterSchema,
+    CachedTokenHolderFilterSchema,
+    HasBaseWalletFilterSchema,
+    HasVerifiedWalletFilterSchema,
+    // Full recipient filter (structured DSL)
+    RecipientFilterSchema,
+    // Legacy field comparison (for backward compatibility)
+    LegacyFieldComparisonSchema
+  ])
+);
+var RecipientFilterDSLSchema = FilterExpressionSchema;
+function validateFilter(filter) {
+  const result = FilterExpressionSchema.safeParse(filter);
+  return result.success;
+}
+function parseFilter(filter) {
+  return FilterExpressionSchema.parse(filter);
+}
+function safeParseFilter(filter) {
+  return FilterExpressionSchema.safeParse(filter);
+}
+function validateRecipientFilter(filter) {
+  const result = RecipientFilterSchema.safeParse(filter);
+  return result.success;
+}
+function parseRecipientFilter(filter) {
+  return RecipientFilterSchema.parse(filter);
+}
+function safeParseRecipientFilter(filter) {
+  return RecipientFilterSchema.safeParse(filter);
+}
+function validateFilterHasTargeting(filter) {
+  const hasSocial = filter.social?.specificFids?.length || filter.social?.specificUsernames?.length || filter.social?.followersOf || filter.social?.followingOf || filter.social?.mutualsWith;
+  if (!hasSocial) {
+    const hasOtherFilters = filter.reputation || filter.onchain || filter.beeperEconomics;
+    return !!hasOtherFilters;
+  }
+  return true;
+}
+function describeFilters(filter) {
+  const descriptions = [];
+  if (filter.platform && filter.platform !== "all") {
+    descriptions.push(`Platform: ${filter.platform}`);
+  }
+  if (filter.social?.specificFids?.length) {
+    descriptions.push(`${filter.social.specificFids.length} specific users`);
+  }
+  if (filter.social?.followersOf) {
+    descriptions.push(`Followers of FID ${filter.social.followersOf}`);
+  }
+  if (filter.social?.mutualsWith) {
+    descriptions.push(`Mutual followers with FID ${filter.social.mutualsWith}`);
+  }
+  if (filter.social?.minFollowers) {
+    descriptions.push(`Min ${filter.social.minFollowers} followers`);
+  }
+  if (filter.social?.signalTokens?.length) {
+    descriptions.push(
+      `Signal token holders: ${filter.social.signalTokens.length} token(s)`
+    );
+  }
+  if (filter.social?.timezones && filter.social.timezones.length > 0) {
+    descriptions.push(`${filter.social.timezones.length} timezone(s)`);
+  }
+  if (filter.social?.countries && filter.social.countries.length > 0) {
+    descriptions.push(`${filter.social.countries.length} country/countries`);
+  }
+  if (filter.social?.roles && filter.social.roles.length > 0) {
+    descriptions.push(`${filter.social.roles.length} role(s)`);
+  }
+  if (filter.reputation?.neynarScoreMin) {
+    descriptions.push(`Neynar score >= ${filter.reputation.neynarScoreMin}`);
+  }
+  if (filter.reputation?.quotientScoreMin) {
+    descriptions.push(`Quotient score >= ${filter.reputation.quotientScoreMin}`);
+  }
+  if (filter.reputation?.spamLabel === "not_spam_only") {
+    descriptions.push("Non-spam only");
+  }
+  if (filter.reputation?.proSubscriptionRequired) {
+    descriptions.push("Pro subscribers");
+  }
+  if (filter.onchain?.hasBaseWallet) {
+    descriptions.push("Base wallet holders");
+  }
+  if (filter.onchain?.tokenHolders?.length) {
+    descriptions.push(
+      `Token holders: ${filter.onchain.tokenHolders.length} token(s)`
+    );
+  }
+  if (filter.onchain?.cachedTokenHolders?.length) {
+    const tokenNames = filter.onchain.cachedTokenHolders.map((t) => t.tokenSymbol || t.contractAddress.slice(0, 10)).join(", ");
+    descriptions.push(`Holders of: ${tokenNames}`);
+  }
+  if (filter.beeperEconomics?.maxAttentionPriceUsd) {
+    descriptions.push(
+      `Max $${filter.beeperEconomics.maxAttentionPriceUsd}/msg`
+    );
+  }
+  if (filter.beeperEconomics?.activeInLastDays) {
+    descriptions.push(
+      `Active in last ${filter.beeperEconomics.activeInLastDays} days`
+    );
+  }
+  if (filter.beeperEconomics?.hasRechargedInLastDays) {
+    descriptions.push(
+      `Recharged in last ${filter.beeperEconomics.hasRechargedInLastDays} days`
+    );
+  }
+  if (filter.beeperEconomics?.minBatteryPercentage) {
+    descriptions.push(`Min ${filter.beeperEconomics.minBatteryPercentage}% battery`);
+  }
+  return descriptions;
+}
+
+// src/schemas/draft.schema.ts
+var NetworkSchema = z.enum([
+  "ethereum",
+  "polygon",
+  "base",
+  "arbitrum",
+  "optimism"
+]);
+var TokenTypeSchema = z.enum(["USDC", "USDT", "ETH", "MATIC"]);
+var DistributionStrategySchema = z.enum([
+  "equal",
+  "weighted",
+  "proportional"
+]);
+var DraftStatusSchema = z.enum(["draft", "quoted", "executed"]);
+var DraftInputSchema = z.object({
+  name: z.string().min(1).max(255),
+  amount: z.string().regex(/^\d+(\.\d+)?$/, "Amount must be a valid decimal string"),
+  token: TokenTypeSchema,
+  network: NetworkSchema,
+  filter: RecipientFilterDSLSchema,
+  strategy: DistributionStrategySchema,
+  weights: z.record(z.string(), z.number().min(0)).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var DraftSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  amount: z.string(),
+  token: TokenTypeSchema,
+  network: NetworkSchema,
+  filter: RecipientFilterDSLSchema,
+  strategy: DistributionStrategySchema,
+  weights: z.record(z.string(), z.number()).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+  status: DraftStatusSchema
+});
+var DraftUpdateSchema = DraftInputSchema.partial();
+function validateDraftInput(input) {
+  return DraftInputSchema.safeParse(input);
+}
+function parseDraftInput(input) {
+  return DraftInputSchema.parse(input);
+}
+function validateDraft(draft) {
+  return DraftSchema.safeParse(draft);
+}
+function parseDraft(draft) {
+  return DraftSchema.parse(draft);
+}
+
+// src/send/draft.ts
+function createDraft(input) {
+  const validated = validateDraftInput2(input);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const draft = {
+    id: randomUUID(),
+    name: validated.name,
+    amount: validated.amount,
+    token: validated.token,
+    network: validated.network,
+    filter: validated.filter,
+    strategy: validated.strategy,
+    createdAt: now,
+    updatedAt: now,
+    status: "draft"
+  };
+  if (validated.weights !== void 0) {
+    draft.weights = validated.weights;
+  }
+  if (validated.metadata !== void 0) {
+    draft.metadata = validated.metadata;
+  }
+  return draft;
+}
+function validateDraftInput2(input) {
+  const result = DraftInputSchema.safeParse(input);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message
+    }));
+    throw new BeeperError({
+      code: ErrorCodes.VALIDATION_ERROR,
+      message: "Invalid draft input",
+      context: {
+        details: { issues }
+      },
+      retryable: false
+    });
+  }
+  return result.data;
+}
+function updateDraft(draft, updates) {
+  const mergedInput = {
+    name: updates.name ?? draft.name,
+    amount: updates.amount ?? draft.amount,
+    token: updates.token ?? draft.token,
+    network: updates.network ?? draft.network,
+    filter: updates.filter ?? draft.filter,
+    strategy: updates.strategy ?? draft.strategy
+  };
+  if (updates.weights !== void 0) {
+    mergedInput.weights = updates.weights;
+  } else if (draft.weights !== void 0) {
+    mergedInput.weights = draft.weights;
+  }
+  if (updates.metadata !== void 0) {
+    mergedInput.metadata = updates.metadata;
+  } else if (draft.metadata !== void 0) {
+    mergedInput.metadata = draft.metadata;
+  }
+  const validated = validateDraftInput2(mergedInput);
+  const updatedDraft = {
+    ...draft,
+    name: validated.name,
+    amount: validated.amount,
+    token: validated.token,
+    network: validated.network,
+    filter: validated.filter,
+    strategy: validated.strategy,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (validated.weights !== void 0) {
+    updatedDraft.weights = validated.weights;
+  }
+  if (validated.metadata !== void 0) {
+    updatedDraft.metadata = validated.metadata;
+  }
+  return updatedDraft;
+}
+function isReadyForQuote(draft) {
+  return draft.status === "draft" && draft.name.length > 0 && parseFloat(draft.amount) > 0;
+}
+var ApiQuoteResponseSchema = z.object({
+  id: z.string().regex(/^qt_[a-zA-Z0-9]+$/),
+  status: z.enum([
+    "pending",
+    "deposit_confirmed",
+    "executing",
+    "completed",
+    "expired",
+    "failed"
+  ]),
+  recipientCount: z.number().int().min(0),
+  totalAmount: z.string(),
+  protocolFee: z.string(),
+  depositAmount: z.string(),
+  depositAddress: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+  depositChainId: z.number().int(),
+  depositTokenAddress: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+  expiresAt: z.string().datetime(),
+  input: z.record(z.unknown()),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+async function createQuote(httpClient, draft, opts) {
+  const body = {
+    filter: draft.filter,
+    tokenAddress: getTokenAddress(draft.token, draft.network),
+    chainId: getChainId(draft.network),
+    amountPerRecipient: draft.amount,
+    budgetCap: opts?.amount ?? draft.amount,
+    memo: draft.name,
+    metadata: draft.metadata,
+    ttlSeconds: 300
+  };
+  const response = await httpClient.post(
+    "/api/v1/sdk/send/quotes",
+    body,
+    {},
+    ApiQuoteResponseSchema
+  );
+  return response.data;
+}
+async function getQuote(httpClient, quoteId) {
+  if (!quoteId.match(/^qt_[a-zA-Z0-9]+$/)) {
+    throw new BeeperError({
+      code: ErrorCodes.VALIDATION_ERROR,
+      message: "Invalid quote ID format. Expected format: qt_xxxxx",
+      retryable: false
+    });
+  }
+  const response = await httpClient.get(
+    `/api/v1/sdk/send/quotes/${quoteId}`,
+    {},
+    ApiQuoteResponseSchema
+  );
+  return response.data;
+}
+function isQuoteExpired(quote) {
+  return quote.status === "expired" || new Date(quote.expiresAt) < /* @__PURE__ */ new Date();
+}
+function isReadyForDeposit(quote) {
+  return quote.status === "pending" && !isQuoteExpired(quote);
+}
+function getChainId(network) {
+  const chainIds = {
+    ethereum: 1,
+    base: 8453,
+    arbitrum: 42161,
+    polygon: 137,
+    optimism: 10
+  };
+  return chainIds[network] ?? 1;
+}
+function getTokenAddress(token, network) {
+  const addresses = {
+    USDC: {
+      ethereum: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      arbitrum: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+      polygon: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+      optimism: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85"
+    },
+    USDT: {
+      ethereum: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+      base: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2",
+      arbitrum: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+      polygon: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+      optimism: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58"
+    }
+  };
+  return addresses[token]?.[network] ?? "0x0000000000000000000000000000000000000000";
+}
+var ConfirmDepositResponseSchema = z.object({
+  quoteId: z.string(),
+  status: z.enum(["confirmed", "pending_verification"]),
+  detectedAmount: z.string(),
+  sufficient: z.boolean(),
+  blockNumber: z.number().int(),
+  confirmedAt: z.string().datetime()
+});
+async function confirmDeposit(httpClient, quoteId, params) {
+  validateQuoteId(quoteId);
+  validateTxHash(params.txHash);
+  if (!params.idempotencyKey || params.idempotencyKey.length === 0) {
+    throw new BeeperError({
+      code: ErrorCodes.VALIDATION_ERROR,
+      message: "Idempotency key is required for deposit confirmation",
+      retryable: false
+    });
+  }
+  const response = await httpClient.post(
+    `/api/v1/sdk/send/quotes/${quoteId}/confirm`,
+    { txHash: params.txHash },
+    { idempotencyKey: params.idempotencyKey },
+    ConfirmDepositResponseSchema
+  );
+  return response.data;
+}
+function isDepositSufficient(result) {
+  return result.status === "confirmed" && result.sufficient;
+}
+function validateTxHash(txHash) {
+  const txHashRegex = /^0x[a-fA-F0-9]{64}$/;
+  if (!txHashRegex.test(txHash)) {
+    throw new BeeperError({
+      code: ErrorCodes.VALIDATION_ERROR,
+      message: "Invalid transaction hash format. Expected 0x followed by 64 hex characters.",
+      context: {
+        details: {
+          provided: txHash,
+          expectedFormat: "0x + 64 hex characters"
+        }
+      },
+      retryable: false
+    });
+  }
+}
+function validateQuoteId(quoteId) {
+  if (!quoteId.match(/^qt_[a-zA-Z0-9]+$/)) {
+    throw new BeeperError({
+      code: ErrorCodes.VALIDATION_ERROR,
+      message: "Invalid quote ID format. Expected format: qt_xxxxx",
+      retryable: false
+    });
+  }
+}
+function generateDepositIdempotencyKey(quoteId) {
+  return `confirm-${quoteId}`;
+}
+var ExecuteSendResponseSchema = z.object({
+  quoteId: z.string(),
+  status: z.enum(["executing", "queued"]),
+  estimatedCompletionAt: z.string().datetime(),
+  batchId: z.string()
+});
+async function executeSend(httpClient, quoteId, params) {
+  validateQuoteId2(quoteId);
+  if (!params.idempotencyKey || params.idempotencyKey.length === 0) {
+    throw new BeeperError({
+      code: ErrorCodes.VALIDATION_ERROR,
+      message: "Idempotency key is required for execution",
+      retryable: false
+    });
+  }
+  const response = await httpClient.post(
+    `/api/v1/sdk/send/quotes/${quoteId}/execute`,
+    {},
+    // Empty body as per HTTP contract
+    { idempotencyKey: params.idempotencyKey },
+    ExecuteSendResponseSchema
+  );
+  return response.data;
+}
+function isExecuting(result) {
+  return result.status === "executing" || result.status === "queued";
+}
+function getEstimatedTimeRemaining(result) {
+  const estimatedCompletion = new Date(result.estimatedCompletionAt);
+  const now = /* @__PURE__ */ new Date();
+  return Math.max(0, estimatedCompletion.getTime() - now.getTime());
+}
+function validateQuoteId2(quoteId) {
+  if (!quoteId.match(/^qt_[a-zA-Z0-9]+$/)) {
+    throw new BeeperError({
+      code: ErrorCodes.VALIDATION_ERROR,
+      message: "Invalid quote ID format. Expected format: qt_xxxxx",
+      retryable: false
+    });
+  }
+}
+function generateExecuteIdempotencyKey(quoteId) {
+  return `execute-${quoteId}`;
+}
+var ReceiptTransactionSchema = z.object({
+  recipient: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+  amount: z.string(),
+  txHash: z.string().nullable(),
+  status: z.enum(["success", "failed"]),
+  error: z.string().nullable().optional()
+});
+var ApiReceiptResponseSchema = z.object({
+  quoteId: z.string(),
+  status: z.enum(["completed", "partial", "failed"]),
+  successCount: z.number().int().min(0),
+  failureCount: z.number().int().min(0),
+  totalSent: z.string(),
+  refundAmount: z.string(),
+  refundTxHash: z.string().nullable().optional(),
+  transactions: z.array(ReceiptTransactionSchema),
+  completedAt: z.string().datetime()
+});
+var DEFAULT_MAX_ATTEMPTS = 60;
+var DEFAULT_INTERVAL_MS = 5e3;
+async function getReceipt(httpClient, quoteId) {
+  if (!quoteId.match(/^qt_[a-zA-Z0-9]+$/)) {
+    throw new BeeperError({
+      code: ErrorCodes.VALIDATION_ERROR,
+      message: "Invalid quote ID format. Expected format: qt_xxxxx",
+      retryable: false
+    });
+  }
+  const response = await httpClient.get(
+    `/api/v1/sdk/send/quotes/${quoteId}/receipt`,
+    {},
+    ApiReceiptResponseSchema
+  );
+  return response.data;
+}
+async function pollUntilComplete(httpClient, quoteId, opts) {
+  const maxAttempts = opts?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  const intervalMs = opts?.intervalMs ?? DEFAULT_INTERVAL_MS;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (opts?.signal?.aborted) {
+      throw new BeeperError({
+        code: ErrorCodes.TIMEOUT,
+        message: "Polling was aborted",
+        retryable: false
+      });
+    }
+    try {
+      const receipt = await getReceipt(httpClient, quoteId);
+      if (isComplete(receipt)) return receipt;
+    } catch (error) {
+      if (!(error instanceof BeeperError && error.context.statusCode === 428)) {
+        throw error;
+      }
+    }
+    if (attempt < maxAttempts - 1) {
+      await sleep(intervalMs, opts?.signal);
+    }
+  }
+  throw new BeeperError({
+    code: ErrorCodes.QUOTE_EXPIRED,
+    message: `Polling timed out after ${maxAttempts} attempts`,
+    context: { details: { quoteId, maxAttempts } },
+    retryable: false
+  });
+}
+function isComplete(receipt) {
+  return ["completed", "partial", "failed"].includes(receipt.status);
+}
+function isSuccess(receipt) {
+  return receipt.status === "completed" && receipt.failureCount === 0;
+}
+function getSuccessRate(receipt) {
+  const total = receipt.successCount + receipt.failureCount;
+  return total === 0 ? 0 : receipt.successCount / total * 100;
+}
+function getFailedTransactions(receipt) {
+  return receipt.transactions.filter((tx) => tx.status === "failed");
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timeoutId);
+      reject(new Error("Aborted"));
+    });
+  });
+}
+
+// src/client/FilterBuilder.ts
+var FilterExpression = class {
+  expression;
+  constructor(expression) {
+    this.expression = expression;
+  }
+  /**
+   * Convert the filter expression to JSON format for API requests
+   */
+  toJSON() {
+    return this.expression;
+  }
+  /**
+   * Combine this filter with another using AND logic
+   */
+  and(other) {
+    return FilterBuilder.and([this, other]);
+  }
+  /**
+   * Combine this filter with another using OR logic
+   */
+  or(other) {
+    return FilterBuilder.or([this, other]);
+  }
+  /**
+   * Negate this filter
+   */
+  not() {
+    return FilterBuilder.not(this);
+  }
+};
+var FilterBuilder = class {
+  // ===========================================================================
+  // Logical Combinators
+  // ===========================================================================
+  /**
+   * Combine multiple filters with AND logic (all must match)
+   * @param filters - Array of filter expressions to combine
+   */
+  static and(filters) {
+    if (filters.length === 0) {
+      throw new Error("and() requires at least one filter");
+    }
+    if (filters.length === 1) {
+      return filters[0];
+    }
+    return new FilterExpression({
+      and: filters.map((f) => f.toJSON())
+    });
+  }
+  /**
+   * Combine multiple filters with OR logic (any must match)
+   * @param filters - Array of filter expressions to combine
+   */
+  static or(filters) {
+    if (filters.length === 0) {
+      throw new Error("or() requires at least one filter");
+    }
+    if (filters.length === 1) {
+      return filters[0];
+    }
+    return new FilterExpression({
+      or: filters.map((f) => f.toJSON())
+    });
+  }
+  /**
+   * Negate a filter (matches users who do NOT match the filter)
+   * @param filter - Filter expression to negate
+   */
+  static not(filter) {
+    return new FilterExpression({
+      not: filter.toJSON()
+    });
+  }
+  // ===========================================================================
+  // Platform Filter
+  // ===========================================================================
+  /**
+   * Filter by platform
+   * @param p - Platform to target: 'all', 'farcaster', or 'twitter'
+   */
+  static platform(p) {
+    return new FilterExpression({ platform: p });
+  }
+  // ===========================================================================
+  // Activity Filters
+  // ===========================================================================
+  /**
+   * Filter users who have been active within the last N days
+   * @param days - Number of days (1-365)
+   */
+  static activeInLastDays(days) {
+    if (days < 1 || days > 365) {
+      throw new Error("activeInLastDays must be between 1 and 365");
+    }
+    return new FilterExpression({ activeInLastDays: days });
+  }
+  // ===========================================================================
+  // Reputation Filters (Neynar Score)
+  // ===========================================================================
+  /**
+   * Filter users with Neynar score >= minimum
+   * @param score - Minimum score (0-1)
+   */
+  static neynarScoreMin(score) {
+    if (score < 0 || score > 1) {
+      throw new Error("neynarScoreMin must be between 0 and 1");
+    }
+    return new FilterExpression({ neynarScoreMin: score });
+  }
+  /**
+   * Filter users with Neynar score <= maximum
+   * @param score - Maximum score (0-1)
+   */
+  static neynarScoreMax(score) {
+    if (score < 0 || score > 1) {
+      throw new Error("neynarScoreMax must be between 0 and 1");
+    }
+    return new FilterExpression({ neynarScoreMax: score });
+  }
+  /**
+   * 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, max) {
+    if (min !== void 0 && (min < 0 || min > 1)) {
+      throw new Error("neynarScoreRange min must be between 0 and 1");
+    }
+    if (max !== void 0 && (max < 0 || max > 1)) {
+      throw new Error("neynarScoreRange max must be between 0 and 1");
+    }
+    const range = {};
+    if (min !== void 0) range.min = min;
+    if (max !== void 0) range.max = max;
+    return new FilterExpression({ neynarScoreRange: range });
+  }
+  /**
+   * Filter by spam label
+   * @param label - Spam label filter: 'not_spam_only', 'spam_only', or 'all'
+   */
+  static spamLabel(label) {
+    return new FilterExpression({ spamLabel: label });
+  }
+  /**
+   * Filter to exclude spam users (convenience method)
+   * @deprecated Use spamLabel('not_spam_only') instead
+   */
+  static excludeSpam() {
+    return new FilterExpression({ spamLabel: "not_spam_only" });
+  }
+  // ===========================================================================
+  // Social Graph Filters (Followers)
+  // ===========================================================================
+  /**
+   * Filter users with at least N followers
+   * @param count - Minimum follower count
+   */
+  static minFollowers(count) {
+    if (count < 0) {
+      throw new Error("minFollowers must be >= 0");
+    }
+    return new FilterExpression({ minFollowers: count });
+  }
+  /**
+   * Filter users with at most N followers
+   * @param count - Maximum follower count
+   */
+  static maxFollowers(count) {
+    if (count < 0) {
+      throw new Error("maxFollowers must be >= 0");
+    }
+    return new FilterExpression({ maxFollowers: count });
+  }
+  /**
+   * Filter users with follower count in a range
+   * @param min - Minimum follower count (optional)
+   * @param max - Maximum follower count (optional)
+   */
+  static followerRange(min, max) {
+    if (min !== void 0 && min < 0) {
+      throw new Error("followerRange min must be >= 0");
+    }
+    if (max !== void 0 && max < 0) {
+      throw new Error("followerRange max must be >= 0");
+    }
+    const range = {};
+    if (min !== void 0) range.min = min;
+    if (max !== void 0) range.max = max;
+    return new FilterExpression({ followerRange: range });
+  }
+  /**
+   * Filter users who follow a specific FID
+   * @param fid - Farcaster ID to check followers of
+   */
+  static followersOf(fid) {
+    if (fid < 1) {
+      throw new Error("followersOf FID must be >= 1");
+    }
+    return new FilterExpression({ followersOf: fid });
+  }
+  /**
+   * Filter users who have mutual follows with a specific FID
+   * @param fid - Farcaster ID to check mutual follows with
+   */
+  static mutualsWith(fid) {
+    if (fid < 1) {
+      throw new Error("mutualsWith FID must be >= 1");
+    }
+    return new FilterExpression({ mutualsWith: fid });
+  }
+  // ===========================================================================
+  // Economics Filters
+  // ===========================================================================
+  /**
+   * Filter users with attention price <= maximum USD
+   * @param usd - Maximum attention price in USD
+   */
+  static maxAttentionPriceUsd(usd) {
+    if (usd < 0) {
+      throw new Error("maxAttentionPriceUsd must be >= 0");
+    }
+    return new FilterExpression({ maxAttentionPriceUsd: usd });
+  }
+  // ===========================================================================
+  // Onchain Filters (Token Holdings)
+  // ===========================================================================
+  /**
+   * Filter users who hold a specific token
+   * @param opts - Token holder options (tokenAddress, chainId, optional minBalance)
+   */
+  static tokenHolder(opts) {
+    if (!/^0x[a-fA-F0-9]{40}$/.test(opts.tokenAddress)) {
+      throw new Error("tokenAddress must be a valid Ethereum address");
+    }
+    if (opts.minBalance !== void 0) {
+      if (!/^[0-9]+$/.test(opts.minBalance)) {
+        throw new Error("minBalance must be a numeric string (wei)");
+      }
+      return new FilterExpression({
+        walletMinBalance: {
+          tokenAddress: opts.tokenAddress,
+          chainId: opts.chainId,
+          minBalance: opts.minBalance
+        }
+      });
+    }
+    return new FilterExpression({
+      walletHasToken: {
+        tokenAddress: opts.tokenAddress,
+        chainId: opts.chainId
+      }
+    });
+  }
+  /**
+   * Filter users who hold any of the specified tokens (multiple token filter)
+   * @param opts - Array of token holder options (max 10)
+   */
+  static tokenHolders(opts) {
+    if (opts.length === 0) {
+      throw new Error("tokenHolders requires at least one token option");
+    }
+    if (opts.length > 10) {
+      throw new Error("tokenHolders cannot exceed 10 tokens");
+    }
+    for (const opt of opts) {
+      if (!/^0x[a-fA-F0-9]{40}$/.test(opt.tokenAddress)) {
+        throw new Error("tokenAddress must be a valid Ethereum address");
+      }
+      if (opt.minBalance !== void 0 && !/^[0-9]+$/.test(opt.minBalance)) {
+        throw new Error("minBalance must be a numeric string (wei)");
+      }
+    }
+    return new FilterExpression({
+      tokenHolders: opts.map((o) => ({
+        tokenAddress: o.tokenAddress,
+        chainId: o.chainId,
+        ...o.minBalance !== void 0 ? { minBalance: o.minBalance } : {}
+      }))
+    });
+  }
+  /**
+   * 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) {
+    if (opts.length === 0) {
+      throw new Error("cachedTokenHolders requires at least one token option");
+    }
+    if (opts.length > 10) {
+      throw new Error("cachedTokenHolders cannot exceed 10 tokens");
+    }
+    for (const opt of opts) {
+      if (!/^0x[a-fA-F0-9]{40}$/.test(opt.tokenAddress)) {
+        throw new Error("tokenAddress must be a valid Ethereum address");
+      }
+      if (opt.minBalance !== void 0 && !/^[0-9]+$/.test(opt.minBalance)) {
+        throw new Error("minBalance must be a numeric string (wei)");
+      }
+    }
+    return new FilterExpression({
+      cachedTokenHolders: opts.map((o) => ({
+        tokenAddress: o.tokenAddress,
+        chainId: o.chainId,
+        ...o.minBalance !== void 0 ? { minBalance: o.minBalance } : {}
+      }))
+    });
+  }
+  /**
+   * Filter users who have configured specific signal tokens
+   * @param tokenAddresses - Array of token contract addresses (max 20)
+   */
+  static signalTokens(tokenAddresses) {
+    if (tokenAddresses.length === 0) {
+      throw new Error("signalTokens requires at least one token address");
+    }
+    if (tokenAddresses.length > 20) {
+      throw new Error("signalTokens cannot exceed 20 tokens");
+    }
+    for (const addr of tokenAddresses) {
+      if (!/^0x[a-fA-F0-9]{40}$/.test(addr)) {
+        throw new Error("tokenAddress must be a valid Ethereum address");
+      }
+    }
+    return new FilterExpression({ signalTokens: tokenAddresses });
+  }
+  /**
+   * Filter users with a wallet on a specific chain
+   * @param chain - Blockchain chain
+   */
+  static walletChain(chain) {
+    return new FilterExpression({ walletChain: chain });
+  }
+  /**
+   * Filter users who have a Base chain wallet
+   */
+  static hasBaseWallet() {
+    return new FilterExpression({ hasBaseWallet: true });
+  }
+  /**
+   * Filter users who have a verified wallet
+   */
+  static hasVerifiedWallet() {
+    return new FilterExpression({ hasVerifiedWallet: true });
+  }
+  // ===========================================================================
+  // Verification Filters
+  // ===========================================================================
+  /**
+   * Filter to only verified users
+   */
+  static verifiedOnly() {
+    return new FilterExpression({ verifiedOnly: true });
+  }
+  /**
+   * Filter to only users with Pro subscription
+   */
+  static proSubscriptionRequired() {
+    return new FilterExpression({ proSubscriptionRequired: true });
+  }
+  /**
+   * Filter users with minimum account tenure
+   * @param days - Minimum number of days since account creation
+   */
+  static minTenureDays(days) {
+    if (days < 0) {
+      throw new Error("minTenureDays must be >= 0");
+    }
+    return new FilterExpression({ minTenureDays: days });
+  }
+  // ===========================================================================
+  // User ID Filters
+  // ===========================================================================
+  /**
+   * Filter by specific user ID
+   * @param id - User ID
+   */
+  static userId(id) {
+    return new FilterExpression({ userId: id });
+  }
+  /**
+   * Filter by multiple user IDs
+   * @param ids - Array of user IDs (max 1000)
+   */
+  static userIds(ids) {
+    if (ids.length === 0) {
+      throw new Error("userIds requires at least one ID");
+    }
+    if (ids.length > 1e3) {
+      throw new Error("userIds cannot exceed 1000 IDs");
+    }
+    return new FilterExpression({ userIds: ids });
+  }
+  /**
+   * Filter by specific Farcaster ID
+   * @param fid - Farcaster ID
+   */
+  static fid(fid) {
+    return new FilterExpression({ fid });
+  }
+  /**
+   * Filter by multiple Farcaster IDs
+   * @param fids - Array of Farcaster IDs (max 1000)
+   */
+  static fids(fids) {
+    if (fids.length === 0) {
+      throw new Error("fids requires at least one FID");
+    }
+    if (fids.length > 1e3) {
+      throw new Error("fids cannot exceed 1000 FIDs");
+    }
+    return new FilterExpression({ fids });
+  }
+  // ===========================================================================
+  // Tag Filters
+  // ===========================================================================
+  /**
+   * Filter users with a specific tag
+   * @param tag - Tag name (max 64 chars)
+   */
+  static hasTag(tag) {
+    if (tag.length > 64) {
+      throw new Error("Tag must be 64 characters or less");
+    }
+    return new FilterExpression({ hasTag: tag });
+  }
+  /**
+   * Filter users with any of the specified tags
+   * @param tags - Array of tag names (1-20 tags)
+   */
+  static hasAnyTag(tags) {
+    if (tags.length === 0 || tags.length > 20) {
+      throw new Error("hasAnyTag requires 1-20 tags");
+    }
+    return new FilterExpression({ hasAnyTag: tags });
+  }
+  /**
+   * Filter users with all of the specified tags
+   * @param tags - Array of tag names (1-20 tags)
+   */
+  static hasAllTags(tags) {
+    if (tags.length === 0 || tags.length > 20) {
+      throw new Error("hasAllTags requires 1-20 tags");
+    }
+    return new FilterExpression({ hasAllTags: tags });
+  }
+  // ===========================================================================
+  // Time-based Filters
+  // ===========================================================================
+  /**
+   * Filter users created after a specific date
+   * @param date - Date or ISO 8601 string
+   */
+  static createdAfter(date) {
+    const isoString = date instanceof Date ? date.toISOString() : date;
+    return new FilterExpression({ createdAfter: isoString });
+  }
+  /**
+   * Filter users created before a specific date
+   * @param date - Date or ISO 8601 string
+   */
+  static createdBefore(date) {
+    const isoString = date instanceof Date ? date.toISOString() : date;
+    return new FilterExpression({ createdBefore: isoString });
+  }
+  /**
+   * Filter users who were last active after a specific date
+   * @param date - Date or ISO 8601 string
+   */
+  static lastActiveAfter(date) {
+    const isoString = date instanceof Date ? date.toISOString() : date;
+    return new FilterExpression({ lastActiveAfter: isoString });
+  }
+  // ===========================================================================
+  // Reward/Quest Filters
+  // ===========================================================================
+  /**
+   * Filter users who completed a specific reward
+   * @param rewardId - Reward ID
+   */
+  static completedReward(rewardId) {
+    return new FilterExpression({ completedReward: rewardId });
+  }
+  /**
+   * Filter users who have NOT completed a specific reward
+   * @param rewardId - Reward ID
+   */
+  static notCompletedReward(rewardId) {
+    return new FilterExpression({ notCompletedReward: rewardId });
+  }
+  /**
+   * Filter users who completed a specific quest
+   * @param questId - Quest ID
+   */
+  static completedQuest(questId) {
+    return new FilterExpression({ completedQuest: questId });
+  }
+  /**
+   * Filter users who have a specific achievement
+   * @param achievementId - Achievement ID
+   */
+  static hasAchievement(achievementId) {
+    return new FilterExpression({ hasAchievement: achievementId });
+  }
+  // ===========================================================================
+  // Geography Filters
+  // ===========================================================================
+  /**
+   * Filter users by timezone
+   * @param zones - Array of timezone options with UTC offset and optional range (max 24)
+   */
+  static timezones(zones) {
+    if (zones.length === 0) {
+      throw new Error("timezones requires at least one timezone");
+    }
+    if (zones.length > 24) {
+      throw new Error("timezones cannot exceed 24 entries");
+    }
+    for (const zone of zones) {
+      if (zone.offset < -12 || zone.offset > 14) {
+        throw new Error("timezone offset must be between -12 and 14");
+      }
+      if (zone.range !== void 0 && (zone.range < 0 || zone.range > 12)) {
+        throw new Error("timezone range must be between 0 and 12");
+      }
+    }
+    return new FilterExpression({ timezones: zones });
+  }
+  /**
+   * 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) {
+    if (codes.length === 0) {
+      throw new Error("countries requires at least one country code");
+    }
+    if (codes.length > 50) {
+      throw new Error("countries cannot exceed 50 country codes");
+    }
+    for (const code of codes) {
+      if (!/^[A-Z]{2}$/.test(code)) {
+        throw new Error("Country codes must be ISO 3166-1 alpha-2 format (e.g., US, CA, GB)");
+      }
+    }
+    return new FilterExpression({ countries: codes.map((code) => ({ code })) });
+  }
+  // ===========================================================================
+  // Engagement & Quality Filters
+  // ===========================================================================
+  /**
+   * 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) {
+    if (score < 0 || score > 1) {
+      throw new Error("quotientScoreMin must be between 0 and 1");
+    }
+    return new FilterExpression({ quotientScoreMin: score });
+  }
+  /**
+   * Filter users with quotient score <= maximum
+   * @param score - Maximum quotient score (0-1)
+   */
+  static quotientScoreMax(score) {
+    if (score < 0 || score > 1) {
+      throw new Error("quotientScoreMax must be between 0 and 1");
+    }
+    return new FilterExpression({ quotientScoreMax: score });
+  }
+  /**
+   * 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, max) {
+    if (min !== void 0 && (min < 0 || min > 1)) {
+      throw new Error("quotientScoreRange min must be between 0 and 1");
+    }
+    if (max !== void 0 && (max < 0 || max > 1)) {
+      throw new Error("quotientScoreRange max must be between 0 and 1");
+    }
+    const range = {};
+    if (min !== void 0) range.min = min;
+    if (max !== void 0) range.max = max;
+    return new FilterExpression({ quotientScoreRange: range });
+  }
+  /**
+   * Filter users with minimum battery percentage
+   * @param pct - Minimum battery percentage (0-100)
+   */
+  static minBatteryPercentage(pct) {
+    if (pct < 0 || pct > 100) {
+      throw new Error("minBatteryPercentage must be between 0 and 100");
+    }
+    return new FilterExpression({ minBatteryPercentage: pct });
+  }
+  /**
+   * Filter users who have recharged their battery within the last N days
+   * @param days - Number of days
+   */
+  static hasRechargedInLastDays(days) {
+    if (days < 1) {
+      throw new Error("hasRechargedInLastDays must be >= 1");
+    }
+    return new FilterExpression({ hasRechargedInLastDays: days });
+  }
+  /**
+   * Exclude users who have already been pinged today
+   */
+  static excludePingedToday() {
+    return new FilterExpression({ excludePingedToday: true });
+  }
+  // ===========================================================================
+  // Opt-In Filters
+  // ===========================================================================
+  /**
+   * Filter to only users who have opted into lottery rewards
+   */
+  static requireLotteryOptIn() {
+    return new FilterExpression({ requireLotteryOptIn: true });
+  }
+  /**
+   * Filter to only users who have opted into quiz rewards
+   */
+  static requireQuizOptIn() {
+    return new FilterExpression({ requireQuizOptIn: true });
+  }
+  // ===========================================================================
+  // Activity Count Filters
+  // ===========================================================================
+  /**
+   * Filter users with minimum cast count
+   * @param count - Minimum number of casts
+   */
+  static minCastCount(count) {
+    if (count < 0) {
+      throw new Error("minCastCount must be >= 0");
+    }
+    return new FilterExpression({ minCastCount: count });
+  }
+  // ===========================================================================
+  // Ordering & Pagination
+  // ===========================================================================
+  /**
+   * Set the order for results
+   * @param order - Order option for sorting results
+   */
+  static orderBy(order) {
+    return new FilterExpression({ orderBy: order });
+  }
+  /**
+   * 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) {
+    console.warn("FilterBuilder.limit() is deprecated. Use budgetCap to control result count.");
+    if (n < 1 || n > 1e4) {
+      throw new Error("limit must be between 1 and 10000");
+    }
+    return new FilterExpression({ limit: n });
+  }
+};
+var GasTierSchema = z.enum(["slow", "standard", "fast"]);
+var QuoteOptionsSchema = z.object({
+  draftId: z.string().uuid(),
+  amount: z.string().regex(/^\d+(\.\d+)?$/).optional(),
+  gasTier: GasTierSchema.optional(),
+  slippageTolerance: z.number().min(0).max(1).optional()
+});
+var QuoteRecipientSchema = z.object({
+  address: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address"),
+  amount: z.string(),
+  share: z.number().min(0).max(1)
+});
+var QuoteSchema2 = z.object({
+  id: z.string().uuid(),
+  draftId: z.string().uuid(),
+  totalAmount: z.string(),
+  estimatedGas: z.string(),
+  gasPrice: z.string(),
+  networkFee: z.string(),
+  platformFee: z.string(),
+  totalCost: z.string(),
+  token: TokenTypeSchema,
+  network: NetworkSchema,
+  recipients: z.array(QuoteRecipientSchema),
+  recipientCount: z.number().int().positive(),
+  expiresAt: z.string().datetime(),
+  createdAt: z.string().datetime(),
+  isValid: z.boolean()
+});
+var ConfirmResultSchema2 = z.object({
+  valid: z.boolean(),
+  invalidReason: z.string().optional(),
+  currentGasEstimate: z.string(),
+  priceChange: z.string(),
+  canExecute: z.boolean()
+});
+var ExecuteStatusSchema = z.enum(["pending", "confirmed", "failed"]);
+var ExecuteResultSchema2 = z.object({
+  id: z.string().uuid(),
+  quoteId: z.string().uuid(),
+  transactionHash: z.string().regex(/^0x[a-fA-F0-9]{64}$/),
+  status: ExecuteStatusSchema,
+  blockNumber: z.number().int().positive().optional(),
+  initiatedAt: z.string().datetime(),
+  confirmedAt: z.string().datetime().optional(),
+  confirmations: z.number().int().min(0),
+  receiptId: z.string().uuid().optional()
+});
+function validateQuoteOptions(options) {
+  return QuoteOptionsSchema.safeParse(options);
+}
+function parseQuoteOptions(options) {
+  return QuoteOptionsSchema.parse(options);
+}
+function validateQuote(quote) {
+  return QuoteSchema2.safeParse(quote);
+}
+function parseQuote(quote) {
+  return QuoteSchema2.parse(quote);
+}
+function validateExecuteResult(result) {
+  return ExecuteResultSchema2.safeParse(result);
+}
+function parseExecuteResult(result) {
+  return ExecuteResultSchema2.parse(result);
+}
+var TransferStatusSchema = z.enum(["success", "failed"]);
+var ReceiptTransferSchema = z.object({
+  recipient: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+  amount: z.string(),
+  status: TransferStatusSchema,
+  logIndex: z.number().int().min(0)
+});
+var ReceiptSchema2 = z.object({
+  id: z.string().uuid(),
+  executionId: z.string().uuid(),
+  quoteId: z.string().uuid(),
+  draftId: z.string().uuid(),
+  transactionHash: z.string().regex(/^0x[a-fA-F0-9]{64}$/),
+  blockNumber: z.number().int().positive(),
+  blockTimestamp: z.string().datetime(),
+  network: NetworkSchema,
+  token: TokenTypeSchema,
+  totalAmount: z.string(),
+  gasUsed: z.string(),
+  gasPrice: z.string(),
+  gasCost: z.string(),
+  transfers: z.array(ReceiptTransferSchema),
+  successfulTransfers: z.number().int().min(0),
+  failedTransfers: z.number().int().min(0),
+  createdAt: z.string().datetime()
+});
+function validateReceipt(receipt) {
+  return ReceiptSchema2.safeParse(receipt);
+}
+function parseReceipt(receipt) {
+  return ReceiptSchema2.parse(receipt);
+}
+
+export { API_BASE_URLS, API_KEY_PREFIXES, ActiveInLastDaysFilterSchema, AgentClient, ApiQuoteResponseSchema, ApiReceiptResponseSchema, BeeperClient, BeeperEconomicsFilterSchema, BeeperError, CachedTokenHolderFilterSchema, CachedTokenHolderSchema, ConfirmDepositResponseSchema, ConfirmResultSchema2 as ConfirmResultSchema, CountryFilterSchema, DistributionStrategySchema, DraftInputSchema, DraftSchema, DraftStatusSchema, DraftUpdateSchema, ENDPOINTS, ErrorCodes, ExcludePingedTodayFilterSchema, ExcludeUsersFilterSchema, ExecuteResultSchema2 as ExecuteResultSchema, ExecuteSendResponseSchema, ExecuteStatusSchema, FILTER_SCHEMA, FieldComparisonSchema, FilterBuilder, FilterExpression, FilterExpressionSchema, FilterOperatorSchema, FilterValueSchema, FollowersOfFilterSchema, FollowingOfFilterSchema, GasTierSchema, HEADERS, HTTP_STATUS_TO_ERROR_CODE, HasBaseWalletFilterSchema, HasRechargedInLastDaysFilterSchema, HasTierFilterSchema, HasVerifiedWalletFilterSchema, HttpClient, IsWaitlistedFilterSchema, LegacyFieldComparisonSchema, LegacyFilterOperatorSchema, LegacyFilterValueSchema, LegacyRecipientFilterDSLSchema, MaxAttentionPriceFilterSchema, MaxFidFilterSchema, MaxFollowersFilterSchema, MaxFollowingFilterSchema, MinAttentionPriceFilterSchema, MinBatteryPercentageFilterSchema, MinCastCountFilterSchema, MinClickThroughRateFilterSchema, MinFidFilterSchema, MinFollowersFilterSchema, MinFollowingFilterSchema, MinProTenureDaysFilterSchema, MinTenureDaysFilterSchema, MutualsWithFilterSchema, NetworkSchema, NeynarScoreMaxFilterSchema, NeynarScoreMinFilterSchema, OnchainFilterSchema, OrderBySchema, PlatformFilterSchema, ProSubscriptionFilterSchema, QUOTE_EXPIRATION_SECONDS, QuoteOptionsSchema, QuoteRecipientSchema, QuoteSchema2 as QuoteSchema, QuotientScoreMaxFilterSchema, QuotientScoreMinFilterSchema, RETRYABLE_ERROR_CODES, RETRY_CONFIG, ReceiptSchema2 as ReceiptSchema, ReceiptTransactionSchema, ReceiptTransferSchema, RecipientFilterDSLSchema, RecipientFilterSchema, ReputationFilterSchema, RequireLotteryOptInFilterSchema, RequireQuizOptInFilterSchema, RolesFilterSchema, SDK_VERSION, SignalTokenFilterSchema, SocialFilterSchema, SpamLabelFilterSchema, SpecificUsersFilterSchema, TIMEOUTS, TimezoneFilterSchema, TokenHolderDiscoverySchema, TokenHolderFilterSchema, TokenTypeSchema, TransferStatusSchema, VerifiedOnlyFilterSchema, createAuthorizationHeader, createHttpConfig, BeeperClient_default 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, validateDraftInput2 as sendValidateDraftInput, validateDraft, validateDraftInput, validateExecuteResult, validateFilter, validateFilterHasTargeting, validateQuote, validateQuoteOptions, validateReceipt, validateRecipientFilter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map