@drip-sdk/node 1.0.2 → 1.0.3

package/dist/index.d.cts

@@ -1,3 +1,466 @@
+/**
+ * StreamMeter - Accumulate usage locally and charge once at the end.
+ *
+ * Perfect for LLM token streaming and other high-frequency metering scenarios
+ * where you want to avoid making an API call for every small increment.
+ *
+ * @example
+ * ```typescript
+ * const meter = drip.createStreamMeter({
+ *   customerId: 'cust_abc123',
+ *   meter: 'tokens',
+ * });
+ *
+ * for await (const chunk of llmStream) {
+ *   meter.add(chunk.tokens);
+ * }
+ *
+ * const result = await meter.flush();
+ * console.log(`Charged ${result.charge.amountUsdc} for ${result.quantity} tokens`);
+ * ```
+ */
+
+/**
+ * Options for creating a StreamMeter.
+ */
+interface StreamMeterOptions {
+    /**
+     * The Drip customer ID to charge.
+     */
+    customerId: string;
+    /**
+     * The usage meter/type to record against.
+     * Must match a meter configured in your pricing plan.
+     */
+    meter: string;
+    /**
+     * Unique key to prevent duplicate charges.
+     * If not provided, one will be generated.
+     */
+    idempotencyKey?: string;
+    /**
+     * Additional metadata to attach to the charge.
+     */
+    metadata?: Record<string, unknown>;
+    /**
+     * Auto-flush when accumulated quantity reaches this threshold.
+     * Useful for long-running streams where you want periodic charges.
+     */
+    flushThreshold?: number;
+    /**
+     * Callback invoked on each add() call.
+     * Useful for logging or progress tracking.
+     */
+    onAdd?: (quantity: number, total: number) => void;
+    /**
+     * Callback invoked after each successful flush.
+     */
+    onFlush?: (result: StreamMeterFlushResult) => void;
+}
+/**
+ * Result of flushing a StreamMeter.
+ */
+interface StreamMeterFlushResult {
+    /** Whether the flush was successful */
+    success: boolean;
+    /** The quantity that was charged */
+    quantity: number;
+    /** The charge result from the API (if quantity > 0) */
+    charge: ChargeResult['charge'] | null;
+    /** Whether this was an idempotent replay */
+    isReplay: boolean;
+}
+/**
+ * Internal charge function type (injected by Drip class).
+ */
+type ChargeFn = (params: ChargeParams) => Promise<ChargeResult>;
+/**
+ * StreamMeter accumulates usage locally and charges once when flushed.
+ *
+ * This is ideal for:
+ * - LLM token streaming (charge once at end of stream)
+ * - High-frequency events (batch small increments)
+ * - Partial failure handling (charge for what was delivered)
+ */
+declare class StreamMeter {
+    private _total;
+    private _flushed;
+    private _flushCount;
+    private readonly _chargeFn;
+    private readonly _options;
+    /**
+     * Creates a new StreamMeter.
+     *
+     * @param chargeFn - The charge function from Drip client
+     * @param options - StreamMeter configuration
+     */
+    constructor(chargeFn: ChargeFn, options: StreamMeterOptions);
+    /**
+     * Current accumulated quantity (not yet charged).
+     */
+    get total(): number;
+    /**
+     * Whether this meter has been flushed at least once.
+     */
+    get isFlushed(): boolean;
+    /**
+     * Number of times this meter has been flushed.
+     */
+    get flushCount(): number;
+    /**
+     * Add quantity to the accumulated total.
+     *
+     * If a flushThreshold is set and the total exceeds it,
+     * this will automatically trigger a flush.
+     *
+     * @param quantity - Amount to add (must be positive)
+     * @returns Promise that resolves when add completes (may trigger auto-flush)
+     */
+    add(quantity: number): Promise<StreamMeterFlushResult | null>;
+    /**
+     * Synchronously add quantity without auto-flush.
+     * Use this for maximum performance when you don't need threshold-based flushing.
+     *
+     * @param quantity - Amount to add (must be positive)
+     */
+    addSync(quantity: number): void;
+    /**
+     * Flush accumulated usage and charge the customer.
+     *
+     * If total is 0, returns a success result with no charge.
+     * After flush, the meter resets to 0 and can be reused.
+     *
+     * @returns The flush result including charge details
+     */
+    flush(): Promise<StreamMeterFlushResult>;
+    /**
+     * Reset the meter without charging.
+     * Use this to discard accumulated usage (e.g., on error before delivery).
+     */
+    reset(): void;
+}
+
+/**
+ * Production-grade resilience patterns for the Drip SDK.
+ *
+ * This module provides:
+ * - Rate limiting (token bucket algorithm)
+ * - Retry with exponential backoff
+ * - Circuit breaker pattern
+ * - Request metrics and observability
+ */
+/**
+ * Configuration for rate limiting.
+ */
+interface RateLimiterConfig {
+    /**
+     * Maximum requests per second.
+     * @default 100
+     */
+    requestsPerSecond: number;
+    /**
+     * Maximum burst size (bucket capacity).
+     * @default 200
+     */
+    burstSize: number;
+    /**
+     * Whether rate limiting is enabled.
+     * @default true
+     */
+    enabled: boolean;
+}
+/**
+ * Thread-safe token bucket rate limiter.
+ *
+ * Allows bursting up to `burstSize` requests, then limits to
+ * `requestsPerSecond` sustained rate.
+ */
+declare class RateLimiter {
+    private readonly config;
+    private tokens;
+    private lastRefill;
+    constructor(config?: Partial<RateLimiterConfig>);
+    /**
+     * Refill tokens based on elapsed time.
+     */
+    private refill;
+    /**
+     * Acquire a token, blocking if necessary.
+     *
+     * @param timeout - Maximum time to wait for a token in ms (undefined = wait forever)
+     * @returns Promise that resolves to true if token acquired, false if timeout
+     */
+    acquire(timeout?: number): Promise<boolean>;
+    /**
+     * Try to acquire a token without waiting.
+     *
+     * @returns true if token acquired, false otherwise
+     */
+    tryAcquire(): boolean;
+    /**
+     * Get current number of available tokens.
+     */
+    get availableTokens(): number;
+    private sleep;
+}
+/**
+ * Configuration for retry behavior.
+ */
+interface RetryConfig {
+    /**
+     * Maximum number of retry attempts.
+     * @default 3
+     */
+    maxRetries: number;
+    /**
+     * Base delay in milliseconds.
+     * @default 100
+     */
+    baseDelayMs: number;
+    /**
+     * Maximum delay in milliseconds.
+     * @default 10000
+     */
+    maxDelayMs: number;
+    /**
+     * Exponential backoff base.
+     * @default 2
+     */
+    exponentialBase: number;
+    /**
+     * Random jitter factor (0-1).
+     * @default 0.1
+     */
+    jitter: number;
+    /**
+     * HTTP status codes that should trigger retry.
+     * @default [429, 500, 502, 503, 504]
+     */
+    retryableStatusCodes: number[];
+    /**
+     * Whether retry is enabled.
+     * @default true
+     */
+    enabled: boolean;
+}
+/**
+ * Error thrown when all retry attempts have been exhausted.
+ */
+declare class RetryExhaustedError extends Error {
+    readonly attempts: number;
+    readonly lastError: Error;
+    constructor(attempts: number, lastError: Error);
+}
+/**
+ * Calculate backoff delay for a given attempt.
+ */
+declare function calculateBackoff(attempt: number, config: RetryConfig): number;
+/**
+ * Check if an error is retryable based on configuration.
+ */
+declare function isRetryableError(error: unknown, config: RetryConfig): boolean;
+/**
+ * Circuit breaker states.
+ */
+type CircuitState = 'closed' | 'open' | 'half_open';
+/**
+ * Configuration for circuit breaker.
+ */
+interface CircuitBreakerConfig {
+    /**
+     * Number of failures before opening circuit.
+     * @default 5
+     */
+    failureThreshold: number;
+    /**
+     * Number of successes in half-open to close circuit.
+     * @default 2
+     */
+    successThreshold: number;
+    /**
+     * Milliseconds to wait before transitioning from open to half-open.
+     * @default 30000
+     */
+    timeoutMs: number;
+    /**
+     * Whether circuit breaker is enabled.
+     * @default true
+     */
+    enabled: boolean;
+}
+/**
+ * Error thrown when circuit breaker is open.
+ */
+declare class CircuitBreakerOpenError extends Error {
+    readonly circuitName: string;
+    readonly timeUntilRetryMs: number;
+    constructor(circuitName: string, timeUntilRetryMs: number);
+}
+/**
+ * Circuit breaker pattern implementation.
+ *
+ * Prevents cascading failures by failing fast when a service is unhealthy.
+ */
+declare class CircuitBreaker {
+    readonly name: string;
+    private readonly config;
+    private state;
+    private failureCount;
+    private successCount;
+    private lastFailureTime;
+    constructor(name: string, config?: Partial<CircuitBreakerConfig>);
+    /**
+     * Get current circuit state.
+     */
+    getState(): CircuitState;
+    /**
+     * Check if state should transition based on timeout.
+     */
+    private checkStateTransition;
+    /**
+     * Record a successful call.
+     */
+    recordSuccess(): void;
+    /**
+     * Record a failed call.
+     */
+    recordFailure(): void;
+    /**
+     * Check if a request should be allowed.
+     */
+    allowRequest(): boolean;
+    /**
+     * Get milliseconds until circuit transitions to half-open.
+     */
+    getTimeUntilRetry(): number;
+    /**
+     * Reset the circuit breaker to initial state.
+     */
+    reset(): void;
+}
+/**
+ * Metrics for a single request.
+ */
+interface RequestMetrics {
+    method: string;
+    endpoint: string;
+    statusCode: number | null;
+    durationMs: number;
+    success: boolean;
+    timestamp: number;
+    error?: string;
+    retryCount: number;
+}
+/**
+ * Aggregated metrics summary.
+ */
+interface MetricsSummary {
+    windowSize: number;
+    totalRequests: number;
+    totalSuccesses: number;
+    totalFailures: number;
+    successRate: number;
+    avgLatencyMs: number;
+    minLatencyMs: number;
+    maxLatencyMs: number;
+    p50LatencyMs: number;
+    p95LatencyMs: number;
+    p99LatencyMs: number;
+    requestsByEndpoint: Record<string, number>;
+    errorsByType: Record<string, number>;
+}
+/**
+ * Collects and aggregates request metrics.
+ *
+ * Thread-safe metrics collection with windowed aggregation.
+ */
+declare class MetricsCollector {
+    private readonly windowSize;
+    private readonly metrics;
+    private totalRequests;
+    private totalSuccesses;
+    private totalFailures;
+    constructor(windowSize?: number);
+    /**
+     * Record a request's metrics.
+     */
+    record(metrics: RequestMetrics): void;
+    /**
+     * Get aggregated metrics summary.
+     */
+    getSummary(): MetricsSummary;
+    /**
+     * Reset all metrics.
+     */
+    reset(): void;
+}
+/**
+ * Combined configuration for all resilience features.
+ */
+interface ResilienceConfig {
+    rateLimiter: RateLimiterConfig;
+    retry: RetryConfig;
+    circuitBreaker: CircuitBreakerConfig;
+    collectMetrics: boolean;
+}
+/**
+ * Create default production configuration.
+ */
+declare function createDefaultResilienceConfig(): ResilienceConfig;
+/**
+ * Create configuration with all features disabled.
+ */
+declare function createDisabledResilienceConfig(): ResilienceConfig;
+/**
+ * Create configuration optimized for high throughput.
+ */
+declare function createHighThroughputResilienceConfig(): ResilienceConfig;
+/**
+ * Health status of resilience components.
+ */
+interface ResilienceHealth {
+    circuitBreaker: {
+        state: CircuitState;
+        timeUntilRetryMs: number;
+    };
+    rateLimiter: {
+        availableTokens: number;
+        requestsPerSecond: number;
+    };
+    metrics: MetricsSummary | null;
+}
+/**
+ * Manages all resilience features for the SDK.
+ *
+ * Provides a unified interface for rate limiting, retry, circuit breaker,
+ * and metrics collection.
+ */
+declare class ResilienceManager {
+    readonly config: ResilienceConfig;
+    readonly rateLimiter: RateLimiter;
+    readonly circuitBreaker: CircuitBreaker;
+    readonly metrics: MetricsCollector | null;
+    constructor(config?: Partial<ResilienceConfig>);
+    /**
+     * Execute a function with all resilience features.
+     *
+     * @param fn - The function to execute
+     * @param method - HTTP method for metrics
+     * @param endpoint - Endpoint for metrics
+     * @returns Result of the function
+     */
+    execute<T>(fn: () => Promise<T>, method?: string, endpoint?: string): Promise<T>;
+    /**
+     * Get current metrics summary.
+     */
+    getMetrics(): MetricsSummary | null;
+    /**
+     * Get health status of all resilience components.
+     */
+    getHealth(): ResilienceHealth;
+    private sleep;
+}
+
 /**
  * Drip SDK - Usage-based billing for Node.js
  *
@@ -7,18 +470,56 @@
  *
  * @packageDocumentation
  */
+
+/**
+ * Retry options for API calls.
+ */
+interface RetryOptions {
+    /**
+     * Maximum number of retry attempts.
+     * @default 3
+     */
+    maxAttempts?: number;
+    /**
+     * Base delay between retries in milliseconds (exponential backoff).
+     * @default 100
+     */
+    baseDelayMs?: number;
+    /**
+     * Maximum delay between retries in milliseconds.
+     * @default 5000
+     */
+    maxDelayMs?: number;
+    /**
+     * Custom function to determine if an error is retryable.
+     * By default, retries on network errors and 5xx status codes.
+     */
+    isRetryable?: (error: unknown) => boolean;
+}
 /**
  * Configuration options for the Drip SDK client.
+ *
+ * All fields are optional - the SDK will read from environment variables:
+ * - `DRIP_API_KEY` - Your Drip API key
+ * - `DRIP_BASE_URL` - Override API base URL (optional)
  */
 interface DripConfig {
     /**
      * Your Drip API key. Obtain this from the Drip dashboard.
-     * @example "drip_live_abc123..."
+     * Falls back to `DRIP_API_KEY` environment variable if not provided.
+     *
+     * Supports both key types:
+     * - **Secret keys** (`sk_live_...` / `sk_test_...`): Full access to all endpoints
+     * - **Public keys** (`pk_live_...` / `pk_test_...`): Safe for client-side use.
+     *   Can access usage, customers, charges, sessions, analytics, etc.
+     *   Cannot access webhook management, API key management, or feature flags.
+     *
+     * @example "sk_live_abc123..." or "pk_live_abc123..."
      */
-    apiKey: string;
+    apiKey?: string;
     /**
      * Base URL for the Drip API. Defaults to production API.
-     * Override for staging/development environments.
+     * Falls back to `DRIP_BASE_URL` environment variable if not provided.
      * @default "https://api.drip.dev/v1"
      */
     baseUrl?: string;
@@ -27,6 +528,36 @@ interface DripConfig {
      * @default 30000
      */
     timeout?: number;
+    /**
+     * Enable production resilience features (rate limiting, retry with backoff,
+     * circuit breaker, metrics).
+     *
+     * - `true`: Use default production settings (100 req/s, 3 retries)
+     * - `'high-throughput'`: Optimized for high throughput (1000 req/s, 2 retries)
+     * - `ResilienceConfig`: Custom configuration object
+     * - `undefined`/`false`: Disabled (default for backward compatibility)
+     *
+     * @example
+     * ```typescript
+     * // Enable with defaults
+     * const drip = new Drip({ apiKey: '...', resilience: true });
+     *
+     * // High throughput mode
+     * const drip = new Drip({ apiKey: '...', resilience: 'high-throughput' });
+     *
+     * // Custom config
+     * const drip = new Drip({
+     *   apiKey: '...',
+     *   resilience: {
+     *     rateLimiter: { requestsPerSecond: 500, burstSize: 1000, enabled: true },
+     *     retry: { maxRetries: 5, enabled: true },
+     *     circuitBreaker: { failureThreshold: 10, enabled: true },
+     *     collectMetrics: true,
+     *   },
+     * });
+     * ```
+     */
+    resilience?: boolean | 'high-throughput' | Partial<ResilienceConfig>;
 }
 /**
  * Parameters for creating a new customer.
@@ -53,8 +584,8 @@ interface CreateCustomerParams {
 interface Customer {
     /** Unique customer ID in Drip */
     id: string;
-    /** Your business ID */
-    businessId: string;
+    /** Your business ID (optional - may not be returned by all endpoints) */
+    businessId?: string;
     /** Your external customer ID (if provided) */
     externalCustomerId: string | null;
     /** Customer's on-chain address */
@@ -95,12 +626,16 @@ interface ListCustomersResponse {
 interface BalanceResult {
     /** Customer ID */
     customerId: string;
-    /** Balance in USDC (6 decimals) */
-    balanceUSDC: string;
-    /** Balance in native token */
-    balanceToken: string;
-    /** ISO timestamp of last balance update */
-    lastUpdated: string;
+    /** On-chain address */
+    onchainAddress: string;
+    /** Balance in USDC (6 decimals) - matches backend field name */
+    balanceUsdc: string;
+    /** Pending charges in USDC */
+    pendingChargesUsdc: string;
+    /** Available USDC (balance minus pending) */
+    availableUsdc: string;
+    /** ISO timestamp of last balance sync */
+    lastSyncedAt: string | null;
 }
 /**
  * Parameters for recording usage and charging a customer.
@@ -122,8 +657,8 @@ interface ChargeParams {
      */
     quantity: number;
     /**
-     * Unique key to prevent duplicate charges.
-     * If provided, retrying with the same key returns the original charge.
+     * Unique key to prevent duplicate charges and map each call to a single event.
+     * Auto-generated if not provided. Retrying with the same key returns the original charge.
      * @example "req_abc123"
      */
     idempotencyKey?: string;
@@ -160,6 +695,60 @@ interface ChargeResult {
  * Possible charge statuses.
  */
 type ChargeStatus = 'PENDING' | 'SUBMITTED' | 'CONFIRMED' | 'FAILED' | 'REFUNDED';
+/**
+ * Parameters for tracking usage without billing.
+ * Use this for internal visibility, pilots, or pre-billing tracking.
+ */
+interface TrackUsageParams {
+    /**
+     * The Drip customer ID to track usage for.
+     * @example "cust_abc123"
+     */
+    customerId: string;
+    /**
+     * The meter/usage type (e.g., 'api_calls', 'tokens').
+     */
+    meter: string;
+    /**
+     * The quantity of usage to record.
+     */
+    quantity: number;
+    /**
+     * Unique key to prevent duplicate records.
+     */
+    idempotencyKey?: string;
+    /**
+     * Human-readable unit label (e.g., 'tokens', 'requests').
+     */
+    units?: string;
+    /**
+     * Human-readable description of this usage event.
+     */
+    description?: string;
+    /**
+     * Additional metadata to attach to this usage event.
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result of tracking usage (no billing).
+ */
+interface TrackUsageResult {
+    /** Whether the usage was recorded */
+    success: boolean;
+    /** The usage event ID */
+    usageEventId: string;
+    /** Customer ID */
+    customerId: string;
+    /** Usage type that was recorded */
+    usageType: string;
+    /** Quantity recorded */
+    quantity: number;
+    /** Whether this customer is internal-only */
+    isInternal: boolean;
+    /** Confirmation message */
+    message: string;
+}
 /**
  * A detailed charge record.
  */
@@ -367,7 +956,7 @@ interface CreateWorkflowParams {
     /** URL-safe identifier (lowercase alphanumeric with underscores/hyphens) */
     slug: string;
     /** Type of workflow */
-    productSurface?: 'RPC' | 'WEBHOOK' | 'AGENT' | 'PIPELINE' | 'CUSTOM';
+    productSurface?: 'API' | 'RPC' | 'WEBHOOK' | 'AGENT' | 'PIPELINE' | 'CUSTOM';
     /** Optional description */
     description?: string;
     /** Additional metadata */
@@ -496,6 +1085,96 @@ interface ListMetersResponse {
     /** Total count */
     count: number;
 }
+/**
+ * Custom pricing map for cost estimation.
+ * Maps usage type to unit price (e.g., { "api_call": "0.005", "token": "0.0001" })
+ */
+type CustomPricing = Record<string, string>;
+/**
+ * Parameters for estimating costs from historical usage events.
+ */
+interface EstimateFromUsageParams {
+    /** Filter to a specific customer (optional) */
+    customerId?: string;
+    /** Start of the period to estimate */
+    periodStart: Date | string;
+    /** End of the period to estimate */
+    periodEnd: Date | string;
+    /** Default price for usage types without pricing plans */
+    defaultUnitPrice?: string;
+    /** Include events that already have charges (default: true) */
+    includeChargedEvents?: boolean;
+    /** Filter to specific usage types */
+    usageTypes?: string[];
+    /** Custom pricing overrides (takes precedence over DB pricing) */
+    customPricing?: CustomPricing;
+}
+/**
+ * A usage item for hypothetical cost estimation.
+ */
+interface HypotheticalUsageItem {
+    /** The usage type (e.g., "api_call", "token") */
+    usageType: string;
+    /** The quantity of usage */
+    quantity: number;
+    /** Override unit price for this specific item */
+    unitPriceOverride?: string;
+}
+/**
+ * Parameters for estimating costs from hypothetical usage.
+ */
+interface EstimateFromHypotheticalParams {
+    /** List of usage items to estimate */
+    items: HypotheticalUsageItem[];
+    /** Default price for usage types without pricing plans */
+    defaultUnitPrice?: string;
+    /** Custom pricing overrides (takes precedence over DB pricing) */
+    customPricing?: CustomPricing;
+}
+/**
+ * A line item in the cost estimate.
+ */
+interface CostEstimateLineItem {
+    /** The usage type */
+    usageType: string;
+    /** Total quantity */
+    quantity: string;
+    /** Unit price used */
+    unitPrice: string;
+    /** Estimated cost in USDC */
+    estimatedCostUsdc: string;
+    /** Number of events (for usage-based estimates) */
+    eventCount?: number;
+    /** Whether a pricing plan was found for this usage type */
+    hasPricingPlan: boolean;
+}
+/**
+ * Response from cost estimation.
+ */
+interface CostEstimateResponse {
+    /** Business ID (optional - may not be returned by all endpoints) */
+    businessId?: string;
+    /** Customer ID (if filtered) */
+    customerId?: string;
+    /** Period start (for usage-based estimates) */
+    periodStart?: string;
+    /** Period end (for usage-based estimates) */
+    periodEnd?: string;
+    /** Breakdown by usage type */
+    lineItems: CostEstimateLineItem[];
+    /** Subtotal in USDC */
+    subtotalUsdc: string;
+    /** Total estimated cost in USDC */
+    estimatedTotalUsdc: string;
+    /** Currency (always USDC) */
+    currency: 'USDC';
+    /** Indicates this is an estimate, not a charge */
+    isEstimate: true;
+    /** When the estimate was generated */
+    generatedAt: string;
+    /** Notes about the estimate (e.g., missing pricing plans, custom pricing applied) */
+    notes: string[];
+}
 /**
  * A single event to record in a run.
  */
@@ -563,48 +1242,146 @@ interface RecordRunResult {
     /** Human-readable summary */
     summary: string;
 }
-/**
- * Full run timeline response.
- */
-interface RunTimeline {
-    run: {
-        id: string;
-        customerId: string;
-        customerName: string | null;
-        workflowId: string;
-        workflowName: string;
-        status: RunStatus;
-        startedAt: string | null;
-        endedAt: string | null;
-        durationMs: number | null;
-        errorMessage: string | null;
-        errorCode: string | null;
-        correlationId: string | null;
-        metadata: Record<string, unknown> | null;
-    };
-    timeline: Array<{
+/**
+ * Full run timeline response from GET /runs/:id/timeline.
+ */
+interface RunTimeline {
+    runId: string;
+    workflowId: string | null;
+    customerId: string;
+    status: RunStatus;
+    startedAt: string | null;
+    endedAt: string | null;
+    durationMs: number | null;
+    events: Array<{
         id: string;
         eventType: string;
-        quantity: number;
-        units: string | null;
+        actionName: string | null;
+        outcome: 'SUCCESS' | 'FAILED' | 'PENDING' | 'TIMEOUT' | 'RETRYING';
+        explanation: string | null;
         description: string | null;
-        costUnits: number | null;
         timestamp: string;
-        correlationId: string | null;
+        durationMs: number | null;
         parentEventId: string | null;
-        charge: {
-            id: string;
-            amountUsdc: string;
-            status: string;
+        retryOfEventId: string | null;
+        attemptNumber: number;
+        retriedByEventId: string | null;
+        costUsdc: string | null;
+        isRetry: boolean;
+        retryChain: {
+            totalAttempts: number;
+            finalOutcome: string;
+            events: string[];
         } | null;
+        metadata: {
+            usageType: string;
+            quantity: number;
+            units: string | null;
+        } | null;
+    }>;
+    anomalies: Array<{
+        id: string;
+        type: string;
+        severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+        title: string;
+        explanation: string;
+        relatedEventIds: string[];
+        detectedAt: string;
+        status: 'OPEN' | 'INVESTIGATING' | 'RESOLVED' | 'FALSE_POSITIVE' | 'IGNORED';
     }>;
+    summary: {
+        totalEvents: number;
+        byType: Record<string, number>;
+        byOutcome: Record<string, number>;
+        retriedEvents: number;
+        failedEvents: number;
+        totalCostUsdc: string | null;
+    };
+    hasMore: boolean;
+    nextCursor: string | null;
+}
+/**
+ * Run details response from GET /runs/:id.
+ */
+interface RunDetails {
+    id: string;
+    customerId: string;
+    customerName: string | null;
+    workflowId: string;
+    workflowName: string;
+    status: RunStatus;
+    startedAt: string | null;
+    endedAt: string | null;
+    durationMs: number | null;
+    errorMessage: string | null;
+    errorCode: string | null;
+    correlationId: string | null;
+    metadata: Record<string, unknown> | null;
     totals: {
         eventCount: number;
         totalQuantity: string;
         totalCostUnits: string;
-        totalChargedUsdc: string;
     };
-    summary: string;
+    _links: {
+        timeline: string;
+    };
+}
+/**
+ * Parameters for wrapping an external API call with usage tracking.
+ * This ensures usage is recorded even if there's a crash/failure after the API call.
+ */
+interface WrapApiCallParams<T> {
+    /**
+     * The Drip customer ID to charge.
+     */
+    customerId: string;
+    /**
+     * The usage meter/type to record against.
+     * Must match a meter configured in your pricing plan.
+     */
+    meter: string;
+    /**
+     * The async function that makes the external API call.
+     * This is the call you want to track (e.g., OpenAI, Anthropic, etc.)
+     */
+    call: () => Promise<T>;
+    /**
+     * Function to extract the usage quantity from the API call result.
+     * @example (result) => result.usage.total_tokens
+     */
+    extractUsage: (result: T) => number;
+    /**
+     * Custom idempotency key prefix.
+     * If not provided, a unique key is generated.
+     * The key ensures retries don't double-charge.
+     */
+    idempotencyKey?: string;
+    /**
+     * Additional metadata to attach to this usage event.
+     */
+    metadata?: Record<string, unknown>;
+    /**
+     * Retry configuration for the Drip charge call.
+     * The external API call is NOT retried (only called once).
+     */
+    retryOptions?: RetryOptions;
+}
+/**
+ * Result of a wrapped API call.
+ */
+interface WrapApiCallResult<T> {
+    /**
+     * The result from the external API call.
+     */
+    result: T;
+    /**
+     * The charge result from Drip.
+     */
+    charge: ChargeResult;
+    /**
+     * The idempotency key used (useful for debugging).
+     */
+    idempotencyKey: string;
 }
 /**
  * Error thrown by Drip SDK operations.
@@ -625,7 +1402,7 @@ declare class DripError extends Error {
  *
  * @example
  * ```typescript
- * import { Drip } from '@drip-billing/sdk';
+ * import { Drip } from '@drip-sdk/node';
  *
  * const drip = new Drip({
  *   apiKey: process.env.DRIP_API_KEY!,
@@ -651,6 +1428,15 @@ declare class Drip {
     private readonly apiKey;
     private readonly baseUrl;
     private readonly timeout;
+    private readonly resilience;
+    /**
+     * The type of API key being used.
+     *
+     * - `'secret'` — Full access (sk_live_... / sk_test_...)
+     * - `'public'` — Client-safe, restricted access (pk_live_... / pk_test_...)
+     * - `'unknown'` — Key format not recognized (legacy or custom)
+     */
+    readonly keyType: 'secret' | 'public' | 'unknown';
     /**
      * Creates a new Drip SDK client.
      *
@@ -659,17 +1445,100 @@ declare class Drip {
      *
      * @example
      * ```typescript
+     * // Basic usage
+     * const drip = new Drip({
+     *   apiKey: 'sk_live_...',
+     * });
+     *
+     * // With production resilience (recommended)
+     * const drip = new Drip({
+     *   apiKey: 'sk_live_...',
+     *   resilience: true,
+     * });
+     *
+     * // High throughput mode
      * const drip = new Drip({
-     *   apiKey: 'drip_live_abc123...',
+     *   apiKey: 'sk_live_...',
+     *   resilience: 'high-throughput',
      * });
      * ```
      */
-    constructor(config: DripConfig);
+    constructor(config?: DripConfig);
+    /**
+     * Asserts that the SDK was initialized with a secret key (sk_).
+     * Throws a clear error if a public key is being used for a secret-key-only operation.
+     * @internal
+     */
+    private assertSecretKey;
     /**
      * Makes an authenticated request to the Drip API.
      * @internal
      */
     private request;
+    /**
+     * Execute the actual HTTP request (internal).
+     * @internal
+     */
+    private rawRequest;
+    /**
+     * Pings the Drip API to check connectivity and measure latency.
+     *
+     * @returns Health status with latency information
+     * @throws {DripError} If the request fails or times out
+     *
+     * @example
+     * ```typescript
+     * const health = await drip.ping();
+     * if (health.ok) {
+     *   console.log(`API healthy, latency: ${health.latencyMs}ms`);
+     * }
+     * ```
+     */
+    ping(): Promise<{
+        ok: boolean;
+        status: string;
+        latencyMs: number;
+        timestamp: number;
+    }>;
+    /**
+     * Get SDK metrics (requires resilience to be enabled).
+     *
+     * Returns aggregated metrics including success rates, latencies, and errors.
+     *
+     * @returns Metrics summary or null if resilience is not enabled
+     *
+     * @example
+     * ```typescript
+     * const drip = new Drip({ apiKey: '...', resilience: true });
+     * // ... make some requests ...
+     *
+     * const metrics = drip.getMetrics();
+     * if (metrics) {
+     *   console.log(`Success rate: ${metrics.successRate.toFixed(1)}%`);
+     *   console.log(`P95 latency: ${metrics.p95LatencyMs.toFixed(0)}ms`);
+     * }
+     * ```
+     */
+    getMetrics(): MetricsSummary | null;
+    /**
+     * Get SDK health status (requires resilience to be enabled).
+     *
+     * Returns health status including circuit breaker state and rate limiter status.
+     *
+     * @returns Health status or null if resilience is not enabled
+     *
+     * @example
+     * ```typescript
+     * const drip = new Drip({ apiKey: '...', resilience: true });
+     *
+     * const health = drip.getHealth();
+     * if (health) {
+     *   console.log(`Circuit: ${health.circuitBreaker.state}`);
+     *   console.log(`Available tokens: ${health.rateLimiter.availableTokens}`);
+     * }
+     * ```
+     */
+    getHealth(): ResilienceHealth | null;
     /**
      * Creates a new customer in your Drip account.
      *
@@ -761,6 +1630,113 @@ declare class Drip {
      * ```
      */
     charge(params: ChargeParams): Promise<ChargeResult>;
+    /**
+     * Wraps an external API call with guaranteed usage recording.
+     *
+     * **This solves the crash-before-record problem:**
+     * ```typescript
+     * // DANGEROUS - usage lost if crash between lines 1 and 2:
+     * const response = await openai.chat.completions.create({...}); // line 1
+     * await drip.charge({ tokens: response.usage.total_tokens });   // line 2
+     *
+     * // SAFE - wrapApiCall guarantees recording with retry:
+     * const { result } = await drip.wrapApiCall({
+     *   call: () => openai.chat.completions.create({...}),
+     *   extractUsage: (r) => r.usage.total_tokens,
+     *   ...
+     * });
+     * ```
+     *
+     * How it works:
+     * 1. Generates idempotency key BEFORE the API call
+     * 2. Makes the external API call (once, no retry)
+     * 3. Records usage in Drip with retry + idempotency
+     * 4. If recording fails transiently, retries are safe (no double-charge)
+     *
+     * @param params - Wrap parameters including the call and usage extractor
+     * @returns The API result and charge details
+     * @throws {DripError} If the Drip charge fails after retries
+     * @throws {Error} If the external API call fails
+     *
+     * @example
+     * ```typescript
+     * // OpenAI example
+     * const { result, charge } = await drip.wrapApiCall({
+     *   customerId: 'cust_abc123',
+     *   meter: 'tokens',
+     *   call: () => openai.chat.completions.create({
+     *     model: 'gpt-4',
+     *     messages: [{ role: 'user', content: 'Hello!' }],
+     *   }),
+     *   extractUsage: (r) => r.usage?.total_tokens ?? 0,
+     * });
+     *
+     * console.log(result.choices[0].message.content);
+     * console.log(`Charged: ${charge.charge.amountUsdc} USDC`);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Anthropic example
+     * const { result, charge } = await drip.wrapApiCall({
+     *   customerId: 'cust_abc123',
+     *   meter: 'tokens',
+     *   call: () => anthropic.messages.create({
+     *     model: 'claude-3-opus-20240229',
+     *     max_tokens: 1024,
+     *     messages: [{ role: 'user', content: 'Hello!' }],
+     *   }),
+     *   extractUsage: (r) => r.usage.input_tokens + r.usage.output_tokens,
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // With custom retry options
+     * const { result } = await drip.wrapApiCall({
+     *   customerId: 'cust_abc123',
+     *   meter: 'api_calls',
+     *   call: () => fetch('https://api.example.com/expensive'),
+     *   extractUsage: () => 1, // Fixed cost per call
+     *   retryOptions: {
+     *     maxAttempts: 5,
+     *     baseDelayMs: 200,
+     *   },
+     * });
+     * ```
+     */
+    wrapApiCall<T>(params: WrapApiCallParams<T>): Promise<WrapApiCallResult<T>>;
+    /**
+     * Records usage for internal visibility WITHOUT billing.
+     *
+     * Use this for:
+     * - Tracking internal team usage without charging
+     * - Pilot programs where you want visibility before billing
+     * - Pre-billing tracking before customer has on-chain wallet
+     *
+     * This does NOT:
+     * - Create a Charge record
+     * - Require customer balance
+     * - Require blockchain/wallet setup
+     *
+     * For billing, use `charge()` instead.
+     *
+     * @param params - The usage tracking parameters
+     * @returns The tracked usage event
+     *
+     * @example
+     * ```typescript
+     * const result = await drip.trackUsage({
+     *   customerId: 'cust_abc123',
+     *   meter: 'api_calls',
+     *   quantity: 100,
+     *   description: 'API calls during trial period',
+     * });
+     *
+     * console.log(`Tracked: ${result.usageEventId}`);
+     * ```
+     */
+    trackUsage(params: TrackUsageParams): Promise<TrackUsageResult>;
     /**
      * Retrieves a specific charge by ID.
      *
@@ -965,8 +1941,8 @@ declare class Drip {
      * @example
      * ```typescript
      * const workflow = await drip.createWorkflow({
-     *   name: 'Prescription Intake',
-     *   slug: 'prescription_intake',
+     *   name: 'Document Processing',
+     *   slug: 'doc_processing',
      *   productSurface: 'AGENT',
      * });
      * ```
@@ -1031,33 +2007,53 @@ declare class Drip {
         totalCostUnits: string | null;
     }>;
     /**
-     * Gets a run's full timeline with events and computed totals.
+     * Gets run details with summary totals.
+     *
+     * For full event history with retry chains and anomalies, use `getRunTimeline()`.
+     *
+     * @param runId - The run ID
+     * @returns Run details with totals
+     *
+     * @example
+     * ```typescript
+     * const run = await drip.getRun('run_abc123');
+     * console.log(`Status: ${run.status}, Events: ${run.totals.eventCount}`);
+     * ```
+     */
+    getRun(runId: string): Promise<RunDetails>;
+    /**
+     * Gets a run's full timeline with events, anomalies, and analytics.
      *
      * This is the key endpoint for debugging "what happened" in an execution.
      *
      * @param runId - The run ID
-     * @returns Full timeline with events and summary
+     * @param options - Pagination and filtering options
+     * @returns Full timeline with events, anomalies, and summary
      *
      * @example
      * ```typescript
-     * const { run, timeline, totals, summary } = await drip.getRunTimeline('run_abc123');
+     * const timeline = await drip.getRunTimeline('run_abc123');
      *
-     * console.log(`Status: ${run.status}`);
-     * console.log(`Summary: ${summary}`);
-     * console.log(`Total cost: ${totals.totalCostUnits}`);
+     * console.log(`Status: ${timeline.status}`);
+     * console.log(`Events: ${timeline.summary.totalEvents}`);
      *
-     * for (const event of timeline) {
-     *   console.log(`${event.eventType}: ${event.quantity} ${event.units}`);
+     * for (const event of timeline.events) {
+     *   console.log(`${event.eventType}: ${event.outcome}`);
      * }
      * ```
      */
-    getRunTimeline(runId: string): Promise<RunTimeline>;
+    getRunTimeline(runId: string, options?: {
+        limit?: number;
+        cursor?: string;
+        includeAnomalies?: boolean;
+        collapseRetries?: boolean;
+    }): Promise<RunTimeline>;
     /**
      * Emits an event to a run.
      *
-     * Events can be stored idempotently when an `idempotencyKey` is provided.
+     * Each event is assigned a unique idempotency key (auto-generated if not provided).
+     * This maps each inference or API call to a single trackable event.
      * Use `Drip.generateIdempotencyKey()` for deterministic key generation.
-     * If `idempotencyKey` is omitted, repeated calls may create duplicate events.
      *
      * @param params - Event parameters
      * @returns The created event
@@ -1098,10 +2094,13 @@ declare class Drip {
         success: boolean;
         created: number;
         duplicates: number;
+        skipped: number;
         events: Array<{
             id: string;
             eventType: string;
             isDuplicate: boolean;
+            skipped?: boolean;
+            reason?: string;
         }>;
     }>;
     /**
@@ -1130,6 +2129,82 @@ declare class Drip {
      * ```
      */
     listMeters(): Promise<ListMetersResponse>;
+    /**
+     * Estimates costs from historical usage events.
+     *
+     * Use this to preview what existing usage would cost before creating charges,
+     * or to run "what-if" scenarios with custom pricing.
+     *
+     * @param params - Parameters for the estimate
+     * @returns Cost estimate with line item breakdown
+     *
+     * @example
+     * ```typescript
+     * // Estimate costs for last month's usage
+     * const estimate = await drip.estimateFromUsage({
+     *   periodStart: new Date('2024-01-01'),
+     *   periodEnd: new Date('2024-01-31'),
+     * });
+     *
+     * console.log(`Estimated total: $${estimate.estimatedTotalUsdc}`);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // "What-if" scenario with custom pricing
+     * const estimate = await drip.estimateFromUsage({
+     *   periodStart: new Date('2024-01-01'),
+     *   periodEnd: new Date('2024-01-31'),
+     *   customPricing: {
+     *     'api_call': '0.005',  // What if we charged $0.005 per call?
+     *     'token': '0.0001',    // What if we charged $0.0001 per token?
+     *   },
+     * });
+     * ```
+     */
+    estimateFromUsage(params: EstimateFromUsageParams): Promise<CostEstimateResponse>;
+    /**
+     * Estimates costs from hypothetical usage.
+     *
+     * Use this for "what-if" scenarios, budget planning, or to preview
+     * costs before usage occurs.
+     *
+     * @param params - Parameters for the estimate
+     * @returns Cost estimate with line item breakdown
+     *
+     * @example
+     * ```typescript
+     * // Estimate what 10,000 API calls and 1M tokens would cost
+     * const estimate = await drip.estimateFromHypothetical({
+     *   items: [
+     *     { usageType: 'api_call', quantity: 10000 },
+     *     { usageType: 'token', quantity: 1000000 },
+     *   ],
+     * });
+     *
+     * console.log(`Estimated total: $${estimate.estimatedTotalUsdc}`);
+     * for (const item of estimate.lineItems) {
+     *   console.log(`  ${item.usageType}: ${item.quantity} × $${item.unitPrice} = $${item.estimatedCostUsdc}`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Compare different pricing scenarios
+     * const currentPricing = await drip.estimateFromHypothetical({
+     *   items: [{ usageType: 'api_call', quantity: 100000 }],
+     * });
+     *
+     * const newPricing = await drip.estimateFromHypothetical({
+     *   items: [{ usageType: 'api_call', quantity: 100000 }],
+     *   customPricing: { 'api_call': '0.0005' },  // 50% discount
+     * });
+     *
+     * console.log(`Current: $${currentPricing.estimatedTotalUsdc}`);
+     * console.log(`With 50% discount: $${newPricing.estimatedTotalUsdc}`);
+     * ```
+     */
+    estimateFromHypothetical(params: EstimateFromHypotheticalParams): Promise<CostEstimateResponse>;
     /**
      * Records a complete agent run in a single call.
      *
@@ -1150,7 +2225,7 @@ declare class Drip {
      * // Record a complete agent run in one call
      * const result = await drip.recordRun({
      *   customerId: 'cust_123',
-     *   workflow: 'prescription_intake',  // Auto-creates if doesn't exist
+     *   workflow: 'doc_processing',  // Auto-creates if doesn't exist
      *   events: [
      *     { eventType: 'agent.start', description: 'Started processing' },
      *     { eventType: 'tool.ocr', quantity: 3, units: 'pages', costUnits: 0.15 },
@@ -1169,7 +2244,7 @@ declare class Drip {
      * // Record a failed run with error details
      * const result = await drip.recordRun({
      *   customerId: 'cust_123',
-     *   workflow: 'prescription_intake',
+     *   workflow: 'doc_processing',
      *   events: [
      *     { eventType: 'agent.start', description: 'Started processing' },
      *     { eventType: 'tool.ocr', quantity: 1, units: 'pages' },
@@ -1214,9 +2289,39 @@ declare class Drip {
         sequence?: number;
     }): string;
     /**
-     * Verifies a webhook signature.
+     * Verifies a webhook signature using HMAC-SHA256.
      *
      * Call this when receiving webhook events to ensure they're authentic.
+     * This is an async method that uses the Web Crypto API for secure verification.
+     *
+     * @param payload - The raw request body (string)
+     * @param signature - The x-drip-signature header value
+     * @param secret - Your webhook secret
+     * @returns Promise resolving to whether the signature is valid
+     *
+     * @example
+     * ```typescript
+     * app.post('/webhooks/drip', async (req, res) => {
+     *   const isValid = await Drip.verifyWebhookSignature(
+     *     req.rawBody,
+     *     req.headers['x-drip-signature'],
+     *     process.env.DRIP_WEBHOOK_SECRET!,
+     *   );
+     *
+     *   if (!isValid) {
+     *     return res.status(401).send('Invalid signature');
+     *   }
+     *
+     *   // Process the webhook...
+     * });
+     * ```
+     */
+    static verifyWebhookSignature(payload: string, signature: string, secret: string, tolerance?: number): Promise<boolean>;
+    /**
+     * Synchronously verifies a webhook signature using HMAC-SHA256.
+     *
+     * This method uses Node.js crypto module and is only available in Node.js environments.
+     * For edge runtimes or browsers, use the async `verifyWebhookSignature` method instead.
      *
      * @param payload - The raw request body (string)
      * @param signature - The x-drip-signature header value
@@ -1226,7 +2331,7 @@ declare class Drip {
      * @example
      * ```typescript
      * app.post('/webhooks/drip', (req, res) => {
-     *   const isValid = Drip.verifyWebhookSignature(
+     *   const isValid = Drip.verifyWebhookSignatureSync(
      *     req.rawBody,
      *     req.headers['x-drip-signature'],
      *     process.env.DRIP_WEBHOOK_SECRET!,
@@ -1240,9 +2345,104 @@ declare class Drip {
      * });
      * ```
      */
-    static verifyWebhookSignature(payload: string, signature: string, secret: string): boolean;
+    static verifyWebhookSignatureSync(payload: string, signature: string, secret: string, tolerance?: number): boolean;
+    /**
+     * Generates a webhook signature for testing purposes.
+     *
+     * This method creates a signature in the same format the Drip backend uses,
+     * allowing you to test your webhook handling code locally.
+     *
+     * @param payload - The webhook payload (JSON string)
+     * @param secret - The webhook secret
+     * @param timestamp - Optional timestamp (defaults to current time)
+     * @returns Signature in format: t=timestamp,v1=hexsignature
+     *
+     * @example
+     * ```typescript
+     * const payload = JSON.stringify({ type: 'charge.succeeded', data: {...} });
+     * const signature = Drip.generateWebhookSignature(payload, 'whsec_test123');
+     *
+     * // Use in tests:
+     * const isValid = Drip.verifyWebhookSignatureSync(payload, signature, 'whsec_test123');
+     * console.log(isValid); // true
+     * ```
+     */
+    static generateWebhookSignature(payload: string, secret: string, timestamp?: number): string;
+    /**
+     * Creates a StreamMeter for accumulating usage and charging once.
+     *
+     * Perfect for LLM token streaming where you want to:
+     * - Accumulate tokens locally (no API call per token)
+     * - Charge once at the end of the stream
+     * - Handle partial failures (charge for what was delivered)
+     *
+     * @param options - StreamMeter configuration
+     * @returns A new StreamMeter instance
+     *
+     * @example
+     * ```typescript
+     * const meter = drip.createStreamMeter({
+     *   customerId: 'cust_abc123',
+     *   meter: 'tokens',
+     * });
+     *
+     * // Accumulate tokens as they stream
+     * for await (const chunk of llmStream) {
+     *   meter.addSync(chunk.tokens);
+     *   yield chunk;
+     * }
+     *
+     * // Single charge at end
+     * const result = await meter.flush();
+     * console.log(`Charged ${result.charge?.amountUsdc} for ${result.quantity} tokens`);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // With auto-flush threshold
+     * const meter = drip.createStreamMeter({
+     *   customerId: 'cust_abc123',
+     *   meter: 'tokens',
+     *   flushThreshold: 10000, // Charge every 10k tokens
+     * });
+     *
+     * for await (const chunk of longStream) {
+     *   await meter.add(chunk.tokens); // May auto-flush
+     * }
+     *
+     * await meter.flush(); // Final flush for remaining tokens
+     * ```
+     */
+    createStreamMeter(options: StreamMeterOptions): StreamMeter;
 }
 
+/**
+ * Pre-initialized Drip client singleton.
+ *
+ * Uses lazy initialization - only creates the client when first accessed.
+ * Reads `DRIP_API_KEY` from environment variables.
+ *
+ * @example
+ * ```typescript
+ * import { drip } from '@drip-sdk/node';
+ *
+ * // Track usage with one line
+ * await drip.trackUsage({ customerId: 'cust_123', meter: 'api_calls', quantity: 1 });
+ *
+ * // Charge with one line
+ * await drip.charge({ customerId: 'cust_123', meter: 'api_calls', quantity: 1 });
+ *
+ * // Record a run
+ * await drip.recordRun({
+ *   customerId: 'cust_123',
+ *   workflow: 'agent-run',
+ *   events: [{ eventType: 'llm.call', quantity: 1000, units: 'tokens' }],
+ *   status: 'COMPLETED',
+ * });
+ * ```
+ */
+declare const drip: Drip;
+
 // @ts-ignore
 export = Drip;
-export { type BalanceResult, type Charge, type ChargeParams, type ChargeResult, type ChargeStatus, type CheckoutParams, type CheckoutResult, type CreateCustomerParams, type CreateWebhookParams, type CreateWebhookResponse, type CreateWorkflowParams, type Customer, type DeleteWebhookResponse, Drip, type DripConfig, DripError, type EmitEventParams, type EndRunParams, type EventResult, type ListChargesOptions, type ListChargesResponse, type ListCustomersOptions, type ListCustomersResponse, type ListMetersResponse, type ListWebhooksResponse, type Meter, type RecordRunEvent, type RecordRunParams, type RecordRunResult, type RunResult, type RunStatus, type RunTimeline, type StartRunParams, type Webhook, type WebhookEventType, type Workflow };
+export { type BalanceResult, type Charge, type ChargeParams, type ChargeResult, type ChargeStatus, type CheckoutParams, type CheckoutResult, CircuitBreaker, type CircuitBreakerConfig, CircuitBreakerOpenError, type CircuitState, type CostEstimateLineItem, type CostEstimateResponse, type CreateCustomerParams, type CreateWebhookParams, type CreateWebhookResponse, type CreateWorkflowParams, type CustomPricing, type Customer, type DeleteWebhookResponse, Drip, type DripConfig, DripError, type EmitEventParams, type EndRunParams, type EstimateFromHypotheticalParams, type EstimateFromUsageParams, type EventResult, type HypotheticalUsageItem, type ListChargesOptions, type ListChargesResponse, type ListCustomersOptions, type ListCustomersResponse, type ListMetersResponse, type ListWebhooksResponse, type Meter, MetricsCollector, type MetricsSummary, RateLimiter, type RateLimiterConfig, type RecordRunEvent, type RecordRunParams, type RecordRunResult, type RequestMetrics, type ResilienceConfig, type ResilienceHealth, ResilienceManager, type RetryConfig, RetryExhaustedError, type RetryOptions, type RunDetails, type RunResult, type RunStatus, type RunTimeline, type StartRunParams, StreamMeter, type StreamMeterFlushResult, type StreamMeterOptions, type TrackUsageParams, type TrackUsageResult, type Webhook, type WebhookEventType, type Workflow, type WrapApiCallParams, type WrapApiCallResult, calculateBackoff, createDefaultResilienceConfig, createDisabledResilienceConfig, createHighThroughputResilienceConfig, drip, isRetryableError };