@beeperbot/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3355 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var zod = require('zod');
+var crypto = require('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 = zod.z.object({
+  id: zod.z.string(),
+  status: zod.z.enum([
+    "pending",
+    "deposit_confirmed",
+    "executing",
+    "completed",
+    "expired",
+    "failed"
+  ]),
+  recipientCount: zod.z.number(),
+  totalAmount: zod.z.string(),
+  protocolFee: zod.z.string(),
+  depositAmount: zod.z.string(),
+  depositAddress: zod.z.string(),
+  depositChainId: zod.z.number(),
+  depositTokenAddress: zod.z.string(),
+  expiresAt: zod.z.string(),
+  input: zod.z.object({
+    filter: zod.z.record(zod.z.unknown()),
+    tokenAddress: zod.z.string(),
+    chainId: zod.z.number(),
+    amountPerRecipient: zod.z.string(),
+    budgetCap: zod.z.string(),
+    memo: zod.z.string().optional(),
+    metadata: zod.z.record(zod.z.unknown()).optional()
+  }),
+  createdAt: zod.z.string(),
+  updatedAt: zod.z.string()
+});
+var AttentionQuoteSchema = zod.z.object({
+  id: zod.z.string(),
+  status: zod.z.enum([
+    "pending",
+    "deposit_confirmed",
+    "executing",
+    "completed",
+    "expired",
+    "failed"
+  ]),
+  recipientCount: zod.z.number(),
+  expiresAt: zod.z.string(),
+  input: zod.z.record(zod.z.unknown()),
+  createdAt: zod.z.string(),
+  updatedAt: zod.z.string()
+}).passthrough();
+var ConfirmResultSchema = zod.z.object({
+  quoteId: zod.z.string(),
+  status: zod.z.enum(["confirmed", "pending_verification"]),
+  detectedAmount: zod.z.string(),
+  sufficient: zod.z.boolean(),
+  blockNumber: zod.z.number(),
+  confirmedAt: zod.z.string()
+});
+var ExecuteResultSchema = zod.z.object({
+  quoteId: zod.z.string(),
+  status: zod.z.enum(["executing", "queued"]),
+  estimatedCompletionAt: zod.z.string(),
+  batchId: zod.z.string()
+});
+var ReceiptSchema = zod.z.object({
+  quoteId: zod.z.string(),
+  status: zod.z.enum(["completed", "partial", "failed"]),
+  successCount: zod.z.number(),
+  failureCount: zod.z.number(),
+  totalSent: zod.z.string(),
+  refundAmount: zod.z.string(),
+  refundTxHash: zod.z.string().optional(),
+  transactions: zod.z.array(
+    zod.z.object({
+      recipient: zod.z.string(),
+      amount: zod.z.string(),
+      txHash: zod.z.string().nullable(),
+      status: zod.z.enum(["success", "failed"]),
+      error: zod.z.string().optional()
+    })
+  ),
+  completedAt: zod.z.string()
+});
+var HealthSchema = zod.z.object({
+  status: zod.z.enum(["healthy", "degraded", "unhealthy"]),
+  version: zod.z.string(),
+  timestamp: zod.z.string(),
+  services: zod.z.object({
+    database: zod.z.enum(["up", "down"]),
+    queue: zod.z.enum(["up", "down"]),
+    oracle: zod.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 = zod.z.enum([
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "nin",
+  "contains",
+  "startsWith",
+  "endsWith"
+]);
+var LegacyFilterValueSchema = zod.z.union([
+  zod.z.string(),
+  zod.z.number(),
+  zod.z.boolean(),
+  zod.z.array(zod.z.string()),
+  zod.z.array(zod.z.number())
+]);
+var LegacyFieldComparisonSchema = zod.z.object({
+  field: zod.z.string().min(1),
+  op: LegacyFilterOperatorSchema,
+  value: LegacyFilterValueSchema
+});
+var LegacyRecipientFilterDSLSchema = zod.z.lazy(
+  () => zod.z.union([
+    // Match all
+    zod.z.object({ all: zod.z.literal(true) }),
+    // Logical AND
+    zod.z.object({ and: zod.z.array(LegacyRecipientFilterDSLSchema).min(1) }),
+    // Logical OR
+    zod.z.object({ or: zod.z.array(LegacyRecipientFilterDSLSchema).min(1) }),
+    // Logical NOT
+    zod.z.object({ not: LegacyRecipientFilterDSLSchema }),
+    // Field comparison
+    LegacyFieldComparisonSchema
+  ])
+);
+var FilterOperatorSchema = LegacyFilterOperatorSchema;
+var FilterValueSchema = LegacyFilterValueSchema;
+var FieldComparisonSchema = LegacyFieldComparisonSchema;
+var PlatformFilterSchema = zod.z.object({
+  platform: zod.z.enum(["all", "farcaster", "twitter"])
+});
+var SpecificUsersFilterSchema = zod.z.object({
+  specificIds: zod.z.array(zod.z.string()).optional(),
+  specificFids: zod.z.array(zod.z.number().int()).optional(),
+  specificUsernames: zod.z.array(zod.z.string()).optional(),
+  specificUsersMode: zod.z.enum(["exclusive", "additive"]).optional()
+});
+var ExcludeUsersFilterSchema = zod.z.object({
+  excludeFids: zod.z.array(zod.z.number().int()).optional(),
+  excludeUsernames: zod.z.array(zod.z.string()).optional()
+});
+var MinFollowersFilterSchema = zod.z.object({
+  minFollowers: zod.z.number().int().min(0)
+});
+var MaxFollowersFilterSchema = zod.z.object({
+  maxFollowers: zod.z.number().int().min(0)
+});
+var MinFollowingFilterSchema = zod.z.object({
+  minFollowing: zod.z.number().int().min(0)
+});
+var MaxFollowingFilterSchema = zod.z.object({
+  maxFollowing: zod.z.number().int().min(0)
+});
+var FollowersOfFilterSchema = zod.z.object({
+  followersOf: zod.z.number().int()
+});
+var FollowingOfFilterSchema = zod.z.object({
+  followingOf: zod.z.number().int()
+});
+var MutualsWithFilterSchema = zod.z.object({
+  mutualsWith: zod.z.number().int()
+});
+var SignalTokenFilterSchema = zod.z.object({
+  signalTokens: zod.z.array(
+    zod.z.object({
+      tokenAddress: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid token address")
+    })
+  )
+});
+var TimezoneFilterSchema = zod.z.object({
+  timezones: zod.z.array(
+    zod.z.object({
+      offset: zod.z.number(),
+      // UTC offset in hours (e.g., -5, +9, +5.5)
+      range: zod.z.number().min(0).max(12).optional()
+      // Range in hours (+/-)
+    })
+  )
+});
+var CountryFilterSchema = zod.z.object({
+  countries: zod.z.array(
+    zod.z.object({
+      code: zod.z.string().length(2)
+      // ISO 3166-1 alpha-2 country code
+    })
+  )
+});
+var RolesFilterSchema = zod.z.object({
+  roles: zod.z.array(zod.z.string())
+});
+var SocialFilterSchema = zod.z.object({
+  specificIds: zod.z.array(zod.z.string()).optional(),
+  specificFids: zod.z.array(zod.z.number().int()).optional(),
+  specificUsernames: zod.z.array(zod.z.string()).optional(),
+  specificUsersMode: zod.z.enum(["exclusive", "additive"]).optional(),
+  excludeFids: zod.z.array(zod.z.number().int()).optional(),
+  excludeUsernames: zod.z.array(zod.z.string()).optional(),
+  followersOf: zod.z.number().int().optional(),
+  followingOf: zod.z.number().int().optional(),
+  mutualsWith: zod.z.number().int().optional(),
+  minFollowers: zod.z.number().int().min(0).optional(),
+  maxFollowers: zod.z.number().int().min(0).optional(),
+  minFollowing: zod.z.number().int().min(0).optional(),
+  maxFollowing: zod.z.number().int().min(0).optional(),
+  signalTokens: zod.z.array(
+    zod.z.object({
+      tokenAddress: zod.z.string()
+    })
+  ).optional(),
+  timezones: zod.z.array(
+    zod.z.object({
+      offset: zod.z.number(),
+      range: zod.z.number().min(0).max(12).optional()
+    })
+  ).optional(),
+  countries: zod.z.array(
+    zod.z.object({
+      code: zod.z.string()
+    })
+  ).optional(),
+  roles: zod.z.array(zod.z.string()).optional()
+});
+var ActiveInLastDaysFilterSchema = zod.z.object({
+  activeInLastDays: zod.z.number().int().min(1).max(365)
+});
+var NeynarScoreMinFilterSchema = zod.z.object({
+  neynarScoreMin: zod.z.number().min(0).max(1)
+});
+var NeynarScoreMaxFilterSchema = zod.z.object({
+  neynarScoreMax: zod.z.number().min(0).max(1)
+});
+var QuotientScoreMinFilterSchema = zod.z.object({
+  quotientScoreMin: zod.z.number().min(0).max(1)
+});
+var QuotientScoreMaxFilterSchema = zod.z.object({
+  quotientScoreMax: zod.z.number().min(0).max(1)
+});
+var SpamLabelFilterSchema = zod.z.object({
+  spamLabel: zod.z.enum(["not_spam_only", "spam_only", "all"])
+});
+var ProSubscriptionFilterSchema = zod.z.object({
+  proSubscriptionRequired: zod.z.boolean()
+});
+var MinProTenureDaysFilterSchema = zod.z.object({
+  minProTenureDays: zod.z.number().int().min(0)
+});
+var MinTenureDaysFilterSchema = zod.z.object({
+  minTenureDays: zod.z.number().int().min(0)
+});
+var VerifiedOnlyFilterSchema = zod.z.object({
+  verifiedOnly: zod.z.boolean()
+});
+var ReputationFilterSchema = zod.z.object({
+  neynarScoreMin: zod.z.number().min(0).max(1).optional(),
+  neynarScoreMax: zod.z.number().min(0).max(1).optional(),
+  quotientScoreMin: zod.z.number().min(0).max(1).optional(),
+  quotientScoreMax: zod.z.number().min(0).max(1).optional(),
+  spamLabel: zod.z.enum(["not_spam_only", "spam_only", "all"]).optional(),
+  proSubscriptionRequired: zod.z.boolean().optional(),
+  minProTenureDays: zod.z.number().int().min(0).optional(),
+  minTenureDays: zod.z.number().int().min(0).optional(),
+  verifiedOnly: zod.z.boolean().optional()
+});
+var MaxAttentionPriceFilterSchema = zod.z.object({
+  maxAttentionPriceUsd: zod.z.number().positive()
+});
+var MinAttentionPriceFilterSchema = zod.z.object({
+  minAttentionPriceUsd: zod.z.number().min(0)
+});
+var MinFidFilterSchema = zod.z.object({
+  minFid: zod.z.number().int().min(1)
+});
+var MaxFidFilterSchema = zod.z.object({
+  maxFid: zod.z.number().int().min(1)
+});
+var MinBatteryPercentageFilterSchema = zod.z.object({
+  minBatteryPercentage: zod.z.number().min(0).max(100)
+});
+var ExcludePingedTodayFilterSchema = zod.z.object({
+  excludePingedToday: zod.z.boolean()
+});
+var HasRechargedInLastDaysFilterSchema = zod.z.object({
+  hasRechargedInLastDays: zod.z.number().int().min(1)
+});
+var RequireLotteryOptInFilterSchema = zod.z.object({
+  requireLotteryOptIn: zod.z.boolean()
+});
+var RequireQuizOptInFilterSchema = zod.z.object({
+  requireQuizOptIn: zod.z.boolean()
+});
+var MinCastCountFilterSchema = zod.z.object({
+  minCastCount: zod.z.number().int().min(0)
+});
+var MinClickThroughRateFilterSchema = zod.z.object({
+  minClickThroughRate: zod.z.number().min(0).max(1)
+});
+var IsWaitlistedFilterSchema = zod.z.object({
+  isWaitlisted: zod.z.boolean()
+});
+var HasTierFilterSchema = zod.z.object({
+  hasTier: zod.z.boolean()
+});
+var BeeperEconomicsFilterSchema = zod.z.object({
+  maxAttentionPriceUsd: zod.z.number().min(0).optional(),
+  minAttentionPriceUsd: zod.z.number().min(0).optional(),
+  minFid: zod.z.number().int().min(1).optional(),
+  maxFid: zod.z.number().int().min(1).optional(),
+  minBatteryPercentage: zod.z.number().min(0).max(100).optional(),
+  excludePingedToday: zod.z.boolean().optional(),
+  hasRechargedInLastDays: zod.z.number().int().min(1).optional(),
+  activeInLastDays: zod.z.number().int().min(0).optional(),
+  requireLotteryOptIn: zod.z.boolean().optional(),
+  requireQuizOptIn: zod.z.boolean().optional(),
+  minCastCount: zod.z.number().int().min(0).optional(),
+  minClickThroughRate: zod.z.number().min(0).max(1).optional(),
+  isWaitlisted: zod.z.boolean().optional(),
+  hasTier: zod.z.boolean().optional()
+});
+var TokenHolderFilterSchema = zod.z.object({
+  tokenHolder: zod.z.object({
+    chain: zod.z.enum(["base", "ethereum"]),
+    contractAddress: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid contract address"),
+    tokenStandard: zod.z.enum(["ERC20", "ERC721", "ERC1155"]),
+    tokenId: zod.z.string().optional(),
+    // Required for ERC1155, optional for ERC721
+    minBalance: zod.z.string().optional(),
+    symbol: zod.z.string().optional(),
+    name: zod.z.string().optional()
+  })
+});
+var CachedTokenHolderFilterSchema = zod.z.object({
+  cachedTokenHolder: zod.z.object({
+    chain: zod.z.enum(["base", "ethereum"]),
+    contractAddress: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid contract address"),
+    tokenStandard: zod.z.enum(["ERC20", "ERC721", "ERC1155"]).default("ERC20"),
+    tokenId: zod.z.string().optional(),
+    tokenSymbol: zod.z.string().optional(),
+    tokenName: zod.z.string().optional(),
+    minBalance: zod.z.union([zod.z.string(), zod.z.number()]).optional()
+  })
+});
+var HasBaseWalletFilterSchema = zod.z.object({
+  hasBaseWallet: zod.z.boolean()
+});
+var HasVerifiedWalletFilterSchema = zod.z.object({
+  hasVerifiedWallet: zod.z.boolean()
+});
+var TokenHolderDiscoverySchema = zod.z.object({
+  chain: zod.z.enum(["base", "ethereum"]),
+  contractAddress: zod.z.string(),
+  tokenStandard: zod.z.enum(["ERC20", "ERC721", "ERC1155"]),
+  tokenId: zod.z.string().optional(),
+  minBalance: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  symbol: zod.z.string().optional(),
+  name: zod.z.string().optional()
+});
+var CachedTokenHolderSchema = zod.z.object({
+  chain: zod.z.enum(["base", "ethereum"]),
+  contractAddress: zod.z.string(),
+  tokenStandard: zod.z.enum(["ERC20", "ERC721", "ERC1155"]).default("ERC20"),
+  tokenId: zod.z.string().optional(),
+  tokenSymbol: zod.z.string().optional(),
+  tokenName: zod.z.string().optional(),
+  minBalance: zod.z.union([zod.z.string(), zod.z.number()]).optional()
+});
+var OnchainFilterSchema = zod.z.object({
+  hasBaseWallet: zod.z.boolean().optional(),
+  tokenHolders: zod.z.array(TokenHolderDiscoverySchema).optional(),
+  cachedTokenHolders: zod.z.array(CachedTokenHolderSchema).optional(),
+  hasVerifiedWallet: zod.z.boolean().optional()
+});
+var OrderBySchema = zod.z.enum([
+  "attention_price_asc",
+  "attention_price_desc",
+  "neynar_score_desc",
+  "followers_desc",
+  "followers_asc",
+  "recent_activity",
+  "battery_desc",
+  "random"
+]);
+var RecipientFilterSchema = zod.z.object({
+  // Platform filter
+  platform: zod.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: zod.z.number().int().min(1).optional()
+});
+var FilterExpressionSchema = zod.z.lazy(
+  () => zod.z.union([
+    // Match all users
+    zod.z.object({ all: zod.z.literal(true) }),
+    // Logical AND
+    zod.z.object({ and: zod.z.array(FilterExpressionSchema).min(1) }),
+    // Logical OR
+    zod.z.object({ or: zod.z.array(FilterExpressionSchema).min(1) }),
+    // Logical NOT
+    zod.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 = zod.z.enum([
+  "ethereum",
+  "polygon",
+  "base",
+  "arbitrum",
+  "optimism"
+]);
+var TokenTypeSchema = zod.z.enum(["USDC", "USDT", "ETH", "MATIC"]);
+var DistributionStrategySchema = zod.z.enum([
+  "equal",
+  "weighted",
+  "proportional"
+]);
+var DraftStatusSchema = zod.z.enum(["draft", "quoted", "executed"]);
+var DraftInputSchema = zod.z.object({
+  name: zod.z.string().min(1).max(255),
+  amount: zod.z.string().regex(/^\d+(\.\d+)?$/, "Amount must be a valid decimal string"),
+  token: TokenTypeSchema,
+  network: NetworkSchema,
+  filter: RecipientFilterDSLSchema,
+  strategy: DistributionStrategySchema,
+  weights: zod.z.record(zod.z.string(), zod.z.number().min(0)).optional(),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var DraftSchema = zod.z.object({
+  id: zod.z.string().uuid(),
+  name: zod.z.string(),
+  amount: zod.z.string(),
+  token: TokenTypeSchema,
+  network: NetworkSchema,
+  filter: RecipientFilterDSLSchema,
+  strategy: DistributionStrategySchema,
+  weights: zod.z.record(zod.z.string(), zod.z.number()).optional(),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  createdAt: zod.z.string().datetime(),
+  updatedAt: zod.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: crypto.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 = zod.z.object({
+  id: zod.z.string().regex(/^qt_[a-zA-Z0-9]+$/),
+  status: zod.z.enum([
+    "pending",
+    "deposit_confirmed",
+    "executing",
+    "completed",
+    "expired",
+    "failed"
+  ]),
+  recipientCount: zod.z.number().int().min(0),
+  totalAmount: zod.z.string(),
+  protocolFee: zod.z.string(),
+  depositAmount: zod.z.string(),
+  depositAddress: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+  depositChainId: zod.z.number().int(),
+  depositTokenAddress: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+  expiresAt: zod.z.string().datetime(),
+  input: zod.z.record(zod.z.unknown()),
+  createdAt: zod.z.string().datetime(),
+  updatedAt: zod.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 = zod.z.object({
+  quoteId: zod.z.string(),
+  status: zod.z.enum(["confirmed", "pending_verification"]),
+  detectedAmount: zod.z.string(),
+  sufficient: zod.z.boolean(),
+  blockNumber: zod.z.number().int(),
+  confirmedAt: zod.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 = zod.z.object({
+  quoteId: zod.z.string(),
+  status: zod.z.enum(["executing", "queued"]),
+  estimatedCompletionAt: zod.z.string().datetime(),
+  batchId: zod.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 = zod.z.object({
+  recipient: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+  amount: zod.z.string(),
+  txHash: zod.z.string().nullable(),
+  status: zod.z.enum(["success", "failed"]),
+  error: zod.z.string().nullable().optional()
+});
+var ApiReceiptResponseSchema = zod.z.object({
+  quoteId: zod.z.string(),
+  status: zod.z.enum(["completed", "partial", "failed"]),
+  successCount: zod.z.number().int().min(0),
+  failureCount: zod.z.number().int().min(0),
+  totalSent: zod.z.string(),
+  refundAmount: zod.z.string(),
+  refundTxHash: zod.z.string().nullable().optional(),
+  transactions: zod.z.array(ReceiptTransactionSchema),
+  completedAt: zod.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 = zod.z.enum(["slow", "standard", "fast"]);
+var QuoteOptionsSchema = zod.z.object({
+  draftId: zod.z.string().uuid(),
+  amount: zod.z.string().regex(/^\d+(\.\d+)?$/).optional(),
+  gasTier: GasTierSchema.optional(),
+  slippageTolerance: zod.z.number().min(0).max(1).optional()
+});
+var QuoteRecipientSchema = zod.z.object({
+  address: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address"),
+  amount: zod.z.string(),
+  share: zod.z.number().min(0).max(1)
+});
+var QuoteSchema2 = zod.z.object({
+  id: zod.z.string().uuid(),
+  draftId: zod.z.string().uuid(),
+  totalAmount: zod.z.string(),
+  estimatedGas: zod.z.string(),
+  gasPrice: zod.z.string(),
+  networkFee: zod.z.string(),
+  platformFee: zod.z.string(),
+  totalCost: zod.z.string(),
+  token: TokenTypeSchema,
+  network: NetworkSchema,
+  recipients: zod.z.array(QuoteRecipientSchema),
+  recipientCount: zod.z.number().int().positive(),
+  expiresAt: zod.z.string().datetime(),
+  createdAt: zod.z.string().datetime(),
+  isValid: zod.z.boolean()
+});
+var ConfirmResultSchema2 = zod.z.object({
+  valid: zod.z.boolean(),
+  invalidReason: zod.z.string().optional(),
+  currentGasEstimate: zod.z.string(),
+  priceChange: zod.z.string(),
+  canExecute: zod.z.boolean()
+});
+var ExecuteStatusSchema = zod.z.enum(["pending", "confirmed", "failed"]);
+var ExecuteResultSchema2 = zod.z.object({
+  id: zod.z.string().uuid(),
+  quoteId: zod.z.string().uuid(),
+  transactionHash: zod.z.string().regex(/^0x[a-fA-F0-9]{64}$/),
+  status: ExecuteStatusSchema,
+  blockNumber: zod.z.number().int().positive().optional(),
+  initiatedAt: zod.z.string().datetime(),
+  confirmedAt: zod.z.string().datetime().optional(),
+  confirmations: zod.z.number().int().min(0),
+  receiptId: zod.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 = zod.z.enum(["success", "failed"]);
+var ReceiptTransferSchema = zod.z.object({
+  recipient: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+  amount: zod.z.string(),
+  status: TransferStatusSchema,
+  logIndex: zod.z.number().int().min(0)
+});
+var ReceiptSchema2 = zod.z.object({
+  id: zod.z.string().uuid(),
+  executionId: zod.z.string().uuid(),
+  quoteId: zod.z.string().uuid(),
+  draftId: zod.z.string().uuid(),
+  transactionHash: zod.z.string().regex(/^0x[a-fA-F0-9]{64}$/),
+  blockNumber: zod.z.number().int().positive(),
+  blockTimestamp: zod.z.string().datetime(),
+  network: NetworkSchema,
+  token: TokenTypeSchema,
+  totalAmount: zod.z.string(),
+  gasUsed: zod.z.string(),
+  gasPrice: zod.z.string(),
+  gasCost: zod.z.string(),
+  transfers: zod.z.array(ReceiptTransferSchema),
+  successfulTransfers: zod.z.number().int().min(0),
+  failedTransfers: zod.z.number().int().min(0),
+  createdAt: zod.z.string().datetime()
+});
+function validateReceipt(receipt) {
+  return ReceiptSchema2.safeParse(receipt);
+}
+function parseReceipt(receipt) {
+  return ReceiptSchema2.parse(receipt);
+}
+
+exports.API_BASE_URLS = API_BASE_URLS;
+exports.API_KEY_PREFIXES = API_KEY_PREFIXES;
+exports.ActiveInLastDaysFilterSchema = ActiveInLastDaysFilterSchema;
+exports.AgentClient = AgentClient;
+exports.ApiQuoteResponseSchema = ApiQuoteResponseSchema;
+exports.ApiReceiptResponseSchema = ApiReceiptResponseSchema;
+exports.BeeperClient = BeeperClient;
+exports.BeeperEconomicsFilterSchema = BeeperEconomicsFilterSchema;
+exports.BeeperError = BeeperError;
+exports.CachedTokenHolderFilterSchema = CachedTokenHolderFilterSchema;
+exports.CachedTokenHolderSchema = CachedTokenHolderSchema;
+exports.ConfirmDepositResponseSchema = ConfirmDepositResponseSchema;
+exports.ConfirmResultSchema = ConfirmResultSchema2;
+exports.CountryFilterSchema = CountryFilterSchema;
+exports.DistributionStrategySchema = DistributionStrategySchema;
+exports.DraftInputSchema = DraftInputSchema;
+exports.DraftSchema = DraftSchema;
+exports.DraftStatusSchema = DraftStatusSchema;
+exports.DraftUpdateSchema = DraftUpdateSchema;
+exports.ENDPOINTS = ENDPOINTS;
+exports.ErrorCodes = ErrorCodes;
+exports.ExcludePingedTodayFilterSchema = ExcludePingedTodayFilterSchema;
+exports.ExcludeUsersFilterSchema = ExcludeUsersFilterSchema;
+exports.ExecuteResultSchema = ExecuteResultSchema2;
+exports.ExecuteSendResponseSchema = ExecuteSendResponseSchema;
+exports.ExecuteStatusSchema = ExecuteStatusSchema;
+exports.FILTER_SCHEMA = FILTER_SCHEMA;
+exports.FieldComparisonSchema = FieldComparisonSchema;
+exports.FilterBuilder = FilterBuilder;
+exports.FilterExpression = FilterExpression;
+exports.FilterExpressionSchema = FilterExpressionSchema;
+exports.FilterOperatorSchema = FilterOperatorSchema;
+exports.FilterValueSchema = FilterValueSchema;
+exports.FollowersOfFilterSchema = FollowersOfFilterSchema;
+exports.FollowingOfFilterSchema = FollowingOfFilterSchema;
+exports.GasTierSchema = GasTierSchema;
+exports.HEADERS = HEADERS;
+exports.HTTP_STATUS_TO_ERROR_CODE = HTTP_STATUS_TO_ERROR_CODE;
+exports.HasBaseWalletFilterSchema = HasBaseWalletFilterSchema;
+exports.HasRechargedInLastDaysFilterSchema = HasRechargedInLastDaysFilterSchema;
+exports.HasTierFilterSchema = HasTierFilterSchema;
+exports.HasVerifiedWalletFilterSchema = HasVerifiedWalletFilterSchema;
+exports.HttpClient = HttpClient;
+exports.IsWaitlistedFilterSchema = IsWaitlistedFilterSchema;
+exports.LegacyFieldComparisonSchema = LegacyFieldComparisonSchema;
+exports.LegacyFilterOperatorSchema = LegacyFilterOperatorSchema;
+exports.LegacyFilterValueSchema = LegacyFilterValueSchema;
+exports.LegacyRecipientFilterDSLSchema = LegacyRecipientFilterDSLSchema;
+exports.MaxAttentionPriceFilterSchema = MaxAttentionPriceFilterSchema;
+exports.MaxFidFilterSchema = MaxFidFilterSchema;
+exports.MaxFollowersFilterSchema = MaxFollowersFilterSchema;
+exports.MaxFollowingFilterSchema = MaxFollowingFilterSchema;
+exports.MinAttentionPriceFilterSchema = MinAttentionPriceFilterSchema;
+exports.MinBatteryPercentageFilterSchema = MinBatteryPercentageFilterSchema;
+exports.MinCastCountFilterSchema = MinCastCountFilterSchema;
+exports.MinClickThroughRateFilterSchema = MinClickThroughRateFilterSchema;
+exports.MinFidFilterSchema = MinFidFilterSchema;
+exports.MinFollowersFilterSchema = MinFollowersFilterSchema;
+exports.MinFollowingFilterSchema = MinFollowingFilterSchema;
+exports.MinProTenureDaysFilterSchema = MinProTenureDaysFilterSchema;
+exports.MinTenureDaysFilterSchema = MinTenureDaysFilterSchema;
+exports.MutualsWithFilterSchema = MutualsWithFilterSchema;
+exports.NetworkSchema = NetworkSchema;
+exports.NeynarScoreMaxFilterSchema = NeynarScoreMaxFilterSchema;
+exports.NeynarScoreMinFilterSchema = NeynarScoreMinFilterSchema;
+exports.OnchainFilterSchema = OnchainFilterSchema;
+exports.OrderBySchema = OrderBySchema;
+exports.PlatformFilterSchema = PlatformFilterSchema;
+exports.ProSubscriptionFilterSchema = ProSubscriptionFilterSchema;
+exports.QUOTE_EXPIRATION_SECONDS = QUOTE_EXPIRATION_SECONDS;
+exports.QuoteOptionsSchema = QuoteOptionsSchema;
+exports.QuoteRecipientSchema = QuoteRecipientSchema;
+exports.QuoteSchema = QuoteSchema2;
+exports.QuotientScoreMaxFilterSchema = QuotientScoreMaxFilterSchema;
+exports.QuotientScoreMinFilterSchema = QuotientScoreMinFilterSchema;
+exports.RETRYABLE_ERROR_CODES = RETRYABLE_ERROR_CODES;
+exports.RETRY_CONFIG = RETRY_CONFIG;
+exports.ReceiptSchema = ReceiptSchema2;
+exports.ReceiptTransactionSchema = ReceiptTransactionSchema;
+exports.ReceiptTransferSchema = ReceiptTransferSchema;
+exports.RecipientFilterDSLSchema = RecipientFilterDSLSchema;
+exports.RecipientFilterSchema = RecipientFilterSchema;
+exports.ReputationFilterSchema = ReputationFilterSchema;
+exports.RequireLotteryOptInFilterSchema = RequireLotteryOptInFilterSchema;
+exports.RequireQuizOptInFilterSchema = RequireQuizOptInFilterSchema;
+exports.RolesFilterSchema = RolesFilterSchema;
+exports.SDK_VERSION = SDK_VERSION;
+exports.SignalTokenFilterSchema = SignalTokenFilterSchema;
+exports.SocialFilterSchema = SocialFilterSchema;
+exports.SpamLabelFilterSchema = SpamLabelFilterSchema;
+exports.SpecificUsersFilterSchema = SpecificUsersFilterSchema;
+exports.TIMEOUTS = TIMEOUTS;
+exports.TimezoneFilterSchema = TimezoneFilterSchema;
+exports.TokenHolderDiscoverySchema = TokenHolderDiscoverySchema;
+exports.TokenHolderFilterSchema = TokenHolderFilterSchema;
+exports.TokenTypeSchema = TokenTypeSchema;
+exports.TransferStatusSchema = TransferStatusSchema;
+exports.VerifiedOnlyFilterSchema = VerifiedOnlyFilterSchema;
+exports.createAuthorizationHeader = createAuthorizationHeader;
+exports.createHttpConfig = createHttpConfig;
+exports.default = BeeperClient_default;
+exports.describeFilters = describeFilters;
+exports.generateDepositIdempotencyKey = generateDepositIdempotencyKey;
+exports.generateExecuteIdempotencyKey = generateExecuteIdempotencyKey;
+exports.generateFilterDocumentation = generateFilterDocumentation;
+exports.generateIdempotencyKey = generateIdempotencyKey;
+exports.getAllFilterNames = getAllFilterNames;
+exports.getApiKeyEnvironment = getApiKeyEnvironment;
+exports.getFilterSchema = getFilterSchema;
+exports.isRetryableCode = isRetryableCode;
+exports.isValidApiKeyFormat = isValidApiKeyFormat;
+exports.maskApiKey = maskApiKey;
+exports.parseDraft = parseDraft;
+exports.parseDraftInput = parseDraftInput;
+exports.parseExecuteResult = parseExecuteResult;
+exports.parseFilter = parseFilter;
+exports.parseQuote = parseQuote;
+exports.parseQuoteOptions = parseQuoteOptions;
+exports.parseReceipt = parseReceipt;
+exports.parseRecipientFilter = parseRecipientFilter;
+exports.safeParseFilter = safeParseFilter;
+exports.safeParseRecipientFilter = safeParseRecipientFilter;
+exports.sendConfirmDeposit = confirmDeposit;
+exports.sendCreateDraft = createDraft;
+exports.sendCreateQuote = createQuote;
+exports.sendExecuteSend = executeSend;
+exports.sendGetEstimatedTimeRemaining = getEstimatedTimeRemaining;
+exports.sendGetFailedTransactions = getFailedTransactions;
+exports.sendGetQuote = getQuote;
+exports.sendGetReceipt = getReceipt;
+exports.sendGetSuccessRate = getSuccessRate;
+exports.sendIsComplete = isComplete;
+exports.sendIsDepositSufficient = isDepositSufficient;
+exports.sendIsExecuting = isExecuting;
+exports.sendIsQuoteExpired = isQuoteExpired;
+exports.sendIsReadyForDeposit = isReadyForDeposit;
+exports.sendIsReadyForQuote = isReadyForQuote;
+exports.sendIsSuccess = isSuccess;
+exports.sendPollUntilComplete = pollUntilComplete;
+exports.sendUpdateDraft = updateDraft;
+exports.sendValidateDraftInput = validateDraftInput2;
+exports.validateDraft = validateDraft;
+exports.validateDraftInput = validateDraftInput;
+exports.validateExecuteResult = validateExecuteResult;
+exports.validateFilter = validateFilter;
+exports.validateFilterHasTargeting = validateFilterHasTargeting;
+exports.validateQuote = validateQuote;
+exports.validateQuoteOptions = validateQuoteOptions;
+exports.validateReceipt = validateReceipt;
+exports.validateRecipientFilter = validateRecipientFilter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map