@parsrun/payments 0.1.0

package/dist/usage/index.d.ts

@@ -0,0 +1,2674 @@
+import { PaymentProviderType } from '../types.js';
+import { k as BillingLogger$1, n as BillingSubscription, B as BillingService } from '../billing-service-LsAFesou.js';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import { NeonHttpDatabase } from 'drizzle-orm/neon-http';
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+import '@parsrun/types';
+import '../webhooks/index.js';
+
+/**
+ * @parsrun/payments - Usage Types
+ * Types for usage-based billing
+ */
+
+type BillingLogger = BillingLogger$1;
+/**
+ * Plan tier levels
+ */
+type PlanTier = 0 | 1 | 2 | 3 | 4;
+/**
+ * Billing interval
+ */
+type BillingInterval = "month" | "year";
+/**
+ * Limit period for features
+ */
+type LimitPeriod = "hour" | "day" | "month" | null;
+/**
+ * Reset period for quotas
+ * - monthly: Reset on the 1st of each calendar month
+ * - billing_cycle: Reset on subscription renewal date
+ */
+type ResetPeriod = "monthly" | "billing_cycle";
+/**
+ * Customer access status
+ * - active: Full access, subscription is current
+ * - past_due: Limited access, payment failed but grace period active
+ * - suspended: No access, multiple payment failures
+ * - canceled: No access, subscription canceled
+ * - unpaid: No access, subscription unpaid
+ */
+type AccessStatus = "active" | "past_due" | "suspended" | "canceled" | "unpaid";
+/**
+ * Access status info for a customer
+ */
+interface AccessStatusInfo {
+    status: AccessStatus;
+    /** When the status was last updated */
+    updatedAt: Date;
+    /** Reason for current status */
+    reason?: string;
+    /** When access will be suspended (for past_due) */
+    suspensionDate?: Date;
+    /** Number of failed payment attempts */
+    failedPaymentAttempts?: number;
+    /** Grace period end date */
+    gracePeriodEnd?: Date;
+}
+/**
+ * Plan definition
+ */
+interface Plan$1 {
+    id: string;
+    name: string;
+    displayName: string;
+    description: string | null;
+    tier: PlanTier;
+    basePrice: number;
+    currency: string;
+    billingInterval: BillingInterval;
+    features: PlanFeature$1[];
+    isActive: boolean;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Plan feature with limits
+ */
+interface PlanFeature$1 {
+    id: string;
+    planId: string;
+    featureKey: string;
+    limitValue: number | null;
+    limitPeriod: LimitPeriod;
+    isEnabled: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Usage event record
+ */
+interface UsageEvent {
+    id: string;
+    tenantId: string;
+    customerId: string;
+    subscriptionId?: string;
+    featureKey: string;
+    quantity: number;
+    timestamp: Date;
+    metadata?: Record<string, unknown>;
+    idempotencyKey?: string;
+}
+/**
+ * Options for tracking usage
+ */
+interface TrackUsageOptions {
+    tenantId: string;
+    customerId: string;
+    subscriptionId?: string;
+    featureKey: string;
+    quantity?: number;
+    metadata?: Record<string, unknown>;
+    idempotencyKey?: string;
+    timestamp?: Date;
+}
+/**
+ * Period type for aggregation
+ */
+type PeriodType = "hour" | "day" | "month";
+/**
+ * Usage aggregate record
+ */
+interface UsageAggregate {
+    id: string;
+    tenantId: string;
+    customerId: string;
+    subscriptionId?: string;
+    featureKey: string;
+    periodStart: Date;
+    periodEnd: Date;
+    periodType: PeriodType;
+    totalQuantity: number;
+    eventCount: number;
+    lastUpdated: Date;
+}
+/**
+ * Options for getting usage
+ */
+interface GetUsageOptions {
+    featureKey?: string;
+    periodType?: PeriodType;
+    startDate?: Date;
+    endDate?: Date;
+    subscriptionId?: string;
+}
+/**
+ * Quota status for a feature
+ */
+interface QuotaStatus {
+    featureKey: string;
+    limit: number | null;
+    used: number;
+    remaining: number | null;
+    percentUsed: number | null;
+    periodStart: Date;
+    periodEnd: Date;
+    isExceeded: boolean;
+    isUnlimited: boolean;
+    /** Overage amount (used - limit) when soft limits enabled */
+    overage?: number;
+    /** Whether overage is allowed for this feature */
+    overageAllowed?: boolean;
+}
+/**
+ * Quota check result
+ */
+interface QuotaCheckResult {
+    allowed: boolean;
+    currentUsage: number;
+    limit: number | null;
+    remaining: number | null;
+    wouldExceed: boolean;
+    percentAfter: number | null;
+}
+/**
+ * Alert status
+ */
+type AlertStatus = "pending" | "triggered" | "acknowledged" | "resolved";
+/**
+ * Usage alert
+ */
+interface UsageAlert {
+    id: string;
+    tenantId: string;
+    customerId: string;
+    subscriptionId?: string;
+    featureKey: string;
+    thresholdPercent: number;
+    status: AlertStatus;
+    currentUsage: number;
+    limit: number;
+    triggeredAt?: Date;
+    acknowledgedAt?: Date;
+    resolvedAt?: Date;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+}
+/**
+ * Subscription lifecycle event types
+ */
+type SubscriptionEventType = "subscription.created" | "subscription.activated" | "subscription.updated" | "subscription.plan_changed" | "subscription.canceled" | "subscription.expired" | "subscription.renewed" | "subscription.trial_started" | "subscription.trial_ended" | "subscription.payment_failed" | "subscription.payment_succeeded" | "subscription.period_reset";
+/**
+ * Subscription lifecycle event
+ */
+interface SubscriptionEvent {
+    type: SubscriptionEventType;
+    subscription: BillingSubscription;
+    previousPlan?: Plan$1;
+    newPlan?: Plan$1;
+    timestamp: Date;
+    provider: PaymentProviderType;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Subscription event handler
+ */
+type SubscriptionHandler = (event: SubscriptionEvent) => void | Promise<void>;
+/**
+ * Usage-specific webhook event types
+ */
+type UsageWebhookEventType = "usage.recorded" | "usage.threshold_reached" | "usage.limit_exceeded" | "usage.limit_reset" | "plan.upgraded" | "plan.downgraded";
+/**
+ * Usage storage interface
+ * Allows pluggable storage backends (database, in-memory, etc.)
+ */
+interface UsageStorage {
+    getPlan(planId: string): Promise<Plan$1 | null>;
+    getPlanByName(name: string): Promise<Plan$1 | null>;
+    listPlans(options?: {
+        activeOnly?: boolean;
+    }): Promise<Plan$1[]>;
+    getPlanFeatures(planId: string): Promise<PlanFeature$1[]>;
+    getFeatureLimit(planId: string, featureKey: string): Promise<PlanFeature$1 | null>;
+    getCustomerPlanId(customerId: string): Promise<string | null>;
+    setCustomerPlanId(customerId: string, planId: string): Promise<void>;
+    recordUsage(event: Omit<UsageEvent, "id">): Promise<UsageEvent>;
+    recordUsageBatch(events: Omit<UsageEvent, "id">[]): Promise<UsageEvent[]>;
+    getUsageEvents(customerId: string, options: GetUsageOptions): Promise<UsageEvent[]>;
+    getAggregate(customerId: string, featureKey: string, periodType: PeriodType, periodStart: Date): Promise<UsageAggregate | null>;
+    upsertAggregate(aggregate: Omit<UsageAggregate, "id">): Promise<UsageAggregate>;
+    getAggregates(customerId: string, options: GetUsageOptions): Promise<UsageAggregate[]>;
+    getCurrentPeriodUsage(customerId: string, featureKey: string, periodStart: Date): Promise<number>;
+    createAlert(alert: Omit<UsageAlert, "id" | "createdAt">): Promise<UsageAlert>;
+    getActiveAlerts(customerId: string): Promise<UsageAlert[]>;
+    updateAlertStatus(alertId: string, status: AlertStatus): Promise<void>;
+    /** Reset usage for a customer (all features or specific ones) */
+    resetUsage(customerId: string, featureKeys?: string[], periodStart?: Date): Promise<void>;
+    /** Reset all aggregates for a customer */
+    resetAggregates(customerId: string, featureKeys?: string[]): Promise<void>;
+    /** Get customer access status */
+    getAccessStatus(customerId: string): Promise<AccessStatusInfo | null>;
+    /** Set customer access status */
+    setAccessStatus(customerId: string, status: AccessStatusInfo): Promise<void>;
+    /** Get customer's current billing cycle dates */
+    getBillingCycle(customerId: string): Promise<{
+        start: Date;
+        end: Date;
+    } | null>;
+    /** Set customer's billing cycle dates */
+    setBillingCycle(customerId: string, start: Date, end: Date): Promise<void>;
+}
+/**
+ * Usage service configuration
+ */
+interface UsageServiceConfig {
+    /** Storage backend */
+    storage: UsageStorage;
+    /** Logger */
+    logger?: BillingLogger;
+    /** Alert thresholds (default: [80, 100]) */
+    alertThresholds?: number[];
+    /** Aggregate usage immediately (default: false - async) */
+    aggregateImmediately?: boolean;
+    /**
+     * Reset period for quotas
+     * - monthly: Reset on the 1st of each calendar month (default)
+     * - billing_cycle: Reset on subscription renewal date
+     */
+    resetPeriod?: ResetPeriod;
+    /**
+     * Auto-reset quotas on subscription renewal
+     * Default: true
+     */
+    autoResetOnRenewal?: boolean;
+    /**
+     * Grace period in days before access is suspended after payment failure
+     * Default: 3 days
+     */
+    paymentGraceDays?: number;
+    /**
+     * Number of failed payments before suspending access
+     * Default: 3
+     */
+    maxFailedPayments?: number;
+    /** Callback when threshold is reached */
+    onThresholdReached?: (alert: UsageAlert) => void | Promise<void>;
+    /** Callback when limit is exceeded */
+    onLimitExceeded?: (quota: QuotaStatus, customerId: string) => void | Promise<void>;
+    /** Callback when period resets */
+    onPeriodReset?: (customerId: string, featureKey: string) => void | Promise<void>;
+    /** Callback when access status changes */
+    onAccessStatusChanged?: (customerId: string, status: AccessStatusInfo, previousStatus?: AccessStatus) => void | Promise<void>;
+}
+/**
+ * Quota manager configuration
+ */
+interface QuotaManagerConfig {
+    /** Storage backend */
+    storage: UsageStorage;
+    /** Logger */
+    logger?: BillingLogger;
+    /** Soft limit behavior - warn but allow (default: false) */
+    softLimits?: boolean;
+    /** Grace period percentage over limit (default: 0) */
+    gracePercent?: number;
+    /**
+     * Features that allow overage (soft limits)
+     * If set, only these features will allow overage.
+     * If not set and softLimits=true, all features allow overage.
+     */
+    overageAllowedFeatures?: string[];
+    /**
+     * Callback when overage is recorded
+     * Called when usage exceeds limit for a soft-limit feature
+     */
+    onOverage?: (customerId: string, featureKey: string, overage: number, limit: number) => void | Promise<void>;
+}
+/**
+ * Usage error codes
+ */
+declare const UsageErrorCodes: {
+    readonly QUOTA_EXCEEDED: "QUOTA_EXCEEDED";
+    readonly PLAN_NOT_FOUND: "PLAN_NOT_FOUND";
+    readonly FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND";
+    readonly CUSTOMER_NOT_FOUND: "CUSTOMER_NOT_FOUND";
+    readonly DUPLICATE_EVENT: "DUPLICATE_EVENT";
+    readonly STORAGE_ERROR: "STORAGE_ERROR";
+    readonly INVALID_PERIOD: "INVALID_PERIOD";
+};
+type UsageErrorCode = keyof typeof UsageErrorCodes;
+/**
+ * Usage error
+ */
+declare class UsageError extends Error {
+    readonly code: UsageErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: UsageErrorCode, details?: Record<string, unknown> | undefined);
+}
+/**
+ * Quota exceeded error
+ */
+declare class QuotaExceededError extends UsageError {
+    readonly featureKey: string;
+    readonly limit: number | null;
+    readonly currentUsage: number;
+    readonly requestedQuantity: number;
+    constructor(featureKey: string, limit: number | null, currentUsage: number, requestedQuantity?: number);
+}
+
+/**
+ * @parsrun/payments - In-Memory Usage Storage
+ * Default storage implementation for development and testing
+ */
+
+/**
+ * In-memory usage storage
+ * For development, testing, and single-instance deployments
+ */
+declare class MemoryUsageStorage implements UsageStorage {
+    private plans;
+    private planFeatures;
+    private customerPlans;
+    private usageEvents;
+    private usageAggregates;
+    private alerts;
+    private idempotencyKeys;
+    private accessStatuses;
+    private billingCycles;
+    getPlan(planId: string): Promise<Plan$1 | null>;
+    getPlanByName(name: string): Promise<Plan$1 | null>;
+    listPlans(options?: {
+        activeOnly?: boolean;
+    }): Promise<Plan$1[]>;
+    /**
+     * Add a plan (for testing/setup)
+     */
+    addPlan(plan: Plan$1): void;
+    getPlanFeatures(planId: string): Promise<PlanFeature$1[]>;
+    getFeatureLimit(planId: string, featureKey: string): Promise<PlanFeature$1 | null>;
+    /**
+     * Add plan features (for testing/setup)
+     */
+    addPlanFeatures(planId: string, features: PlanFeature$1[]): void;
+    getCustomerPlanId(customerId: string): Promise<string | null>;
+    setCustomerPlanId(customerId: string, planId: string): Promise<void>;
+    recordUsage(event: Omit<UsageEvent, "id">): Promise<UsageEvent>;
+    recordUsageBatch(events: Omit<UsageEvent, "id">[]): Promise<UsageEvent[]>;
+    getUsageEvents(customerId: string, options: GetUsageOptions): Promise<UsageEvent[]>;
+    private getAggregateKey;
+    getAggregate(customerId: string, featureKey: string, periodType: PeriodType, periodStart: Date): Promise<UsageAggregate | null>;
+    upsertAggregate(aggregate: Omit<UsageAggregate, "id">): Promise<UsageAggregate>;
+    getAggregates(customerId: string, options: GetUsageOptions): Promise<UsageAggregate[]>;
+    getCurrentPeriodUsage(customerId: string, featureKey: string, periodStart: Date): Promise<number>;
+    createAlert(alert: Omit<UsageAlert, "id" | "createdAt">): Promise<UsageAlert>;
+    getActiveAlerts(customerId: string): Promise<UsageAlert[]>;
+    updateAlertStatus(alertId: string, status: AlertStatus): Promise<void>;
+    resetUsage(customerId: string, featureKeys?: string[], periodStart?: Date): Promise<void>;
+    resetAggregates(customerId: string, featureKeys?: string[]): Promise<void>;
+    getAccessStatus(customerId: string): Promise<AccessStatusInfo | null>;
+    setAccessStatus(customerId: string, status: AccessStatusInfo): Promise<void>;
+    getBillingCycle(customerId: string): Promise<{
+        start: Date;
+        end: Date;
+    } | null>;
+    setBillingCycle(customerId: string, start: Date, end: Date): Promise<void>;
+    /**
+     * Clear all data (for testing)
+     */
+    clear(): void;
+    /**
+     * Get stats (for debugging)
+     */
+    getStats(): {
+        plans: number;
+        customers: number;
+        events: number;
+        aggregates: number;
+        alerts: number;
+        accessStatuses: number;
+        billingCycles: number;
+    };
+}
+/**
+ * Create in-memory usage storage
+ */
+declare function createMemoryUsageStorage(): MemoryUsageStorage;
+
+/**
+ * @parsrun/payments - Drizzle Usage Storage
+ * Database-backed storage implementation using Drizzle ORM
+ *
+ * @example
+ * ```typescript
+ * import { createDrizzleUsageStorage } from "@parsrun/payments";
+ * import { drizzle } from "drizzle-orm/postgres-js";
+ * import postgres from "postgres";
+ *
+ * const client = postgres(process.env.DATABASE_URL);
+ * const db = drizzle(client);
+ *
+ * const storage = createDrizzleUsageStorage({ db });
+ *
+ * const usageService = createUsageService({ storage });
+ * ```
+ */
+
+/**
+ * Supported Drizzle database types
+ */
+type DrizzleDb = PostgresJsDatabase<any> | NeonHttpDatabase<any>;
+/**
+ * Drizzle storage configuration
+ */
+interface DrizzleUsageStorageConfig {
+    /** Drizzle database instance */
+    db: DrizzleDb;
+    /** Table prefix (optional, for multi-tenant setups) */
+    tablePrefix?: string;
+}
+/**
+ * Drizzle-backed usage storage
+ * Persists all usage data to PostgreSQL/Neon database
+ */
+declare class DrizzleUsageStorage implements UsageStorage {
+    private readonly db;
+    constructor(config: DrizzleUsageStorageConfig);
+    getPlan(planId: string): Promise<Plan$1 | null>;
+    getPlanByName(name: string): Promise<Plan$1 | null>;
+    listPlans(options?: {
+        activeOnly?: boolean;
+    }): Promise<Plan$1[]>;
+    private mapRowToPlan;
+    getPlanFeatures(planId: string): Promise<PlanFeature$1[]>;
+    getFeatureLimit(planId: string, featureKey: string): Promise<PlanFeature$1 | null>;
+    private mapRowToPlanFeature;
+    getCustomerPlanId(customerId: string): Promise<string | null>;
+    setCustomerPlanId(customerId: string, planId: string): Promise<void>;
+    recordUsage(event: Omit<UsageEvent, "id">): Promise<UsageEvent>;
+    recordUsageBatch(events: Omit<UsageEvent, "id">[]): Promise<UsageEvent[]>;
+    getUsageEvents(customerId: string, options: GetUsageOptions): Promise<UsageEvent[]>;
+    private mapRowToUsageEvent;
+    getAggregate(customerId: string, featureKey: string, periodType: PeriodType, periodStart: Date): Promise<UsageAggregate | null>;
+    upsertAggregate(aggregate: Omit<UsageAggregate, "id">): Promise<UsageAggregate>;
+    getAggregates(customerId: string, options: GetUsageOptions): Promise<UsageAggregate[]>;
+    getCurrentPeriodUsage(customerId: string, featureKey: string, periodStart: Date): Promise<number>;
+    private mapRowToUsageAggregate;
+    createAlert(alert: Omit<UsageAlert, "id" | "createdAt">): Promise<UsageAlert>;
+    getActiveAlerts(customerId: string): Promise<UsageAlert[]>;
+    updateAlertStatus(alertId: string, status: AlertStatus): Promise<void>;
+    private mapRowToUsageAlert;
+    resetUsage(customerId: string, featureKeys?: string[], periodStart?: Date): Promise<void>;
+    resetAggregates(customerId: string, featureKeys?: string[]): Promise<void>;
+    getAccessStatus(customerId: string): Promise<AccessStatusInfo | null>;
+    setAccessStatus(customerId: string, status: AccessStatusInfo): Promise<void>;
+    getBillingCycle(customerId: string): Promise<{
+        start: Date;
+        end: Date;
+    } | null>;
+    setBillingCycle(customerId: string, start: Date, end: Date): Promise<void>;
+    /**
+     * Create or update a plan
+     */
+    upsertPlan(plan: Omit<Plan$1, "createdAt" | "updatedAt">): Promise<Plan$1>;
+    /**
+     * Delete a plan
+     */
+    deletePlan(planId: string): Promise<void>;
+}
+/**
+ * Create Drizzle-backed usage storage
+ */
+declare function createDrizzleUsageStorage(config: DrizzleUsageStorageConfig): DrizzleUsageStorage;
+
+/**
+ * @parsrun/payments - Usage Database Schema
+ * Drizzle ORM schema for usage-based billing tables
+ *
+ * These tables store:
+ * - Plans and features with limits
+ * - Customer plan assignments
+ * - Usage events and aggregates
+ * - Access status and billing cycles
+ * - Usage alerts
+ */
+/**
+ * Plans table - defines billing plans with tiers
+ */
+declare const plans: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "usage_plans";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "usage_plans";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: drizzle_orm_pg_core.PgColumn<{
+            name: "name";
+            tableName: "usage_plans";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        displayName: drizzle_orm_pg_core.PgColumn<{
+            name: "display_name";
+            tableName: "usage_plans";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: drizzle_orm_pg_core.PgColumn<{
+            name: "description";
+            tableName: "usage_plans";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tier: drizzle_orm_pg_core.PgColumn<{
+            name: "tier";
+            tableName: "usage_plans";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        basePrice: drizzle_orm_pg_core.PgColumn<{
+            name: "base_price";
+            tableName: "usage_plans";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currency: drizzle_orm_pg_core.PgColumn<{
+            name: "currency";
+            tableName: "usage_plans";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        billingInterval: drizzle_orm_pg_core.PgColumn<{
+            name: "billing_interval";
+            tableName: "usage_plans";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isActive: drizzle_orm_pg_core.PgColumn<{
+            name: "is_active";
+            tableName: "usage_plans";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "usage_plans";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "usage_plans";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "usage_plans";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Plan features table - defines feature limits for each plan
+ */
+declare const planFeatures: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "usage_plan_features";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "usage_plan_features";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        planId: drizzle_orm_pg_core.PgColumn<{
+            name: "plan_id";
+            tableName: "usage_plan_features";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        featureKey: drizzle_orm_pg_core.PgColumn<{
+            name: "feature_key";
+            tableName: "usage_plan_features";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        limitValue: drizzle_orm_pg_core.PgColumn<{
+            name: "limit_value";
+            tableName: "usage_plan_features";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        limitPeriod: drizzle_orm_pg_core.PgColumn<{
+            name: "limit_period";
+            tableName: "usage_plan_features";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isEnabled: drizzle_orm_pg_core.PgColumn<{
+            name: "is_enabled";
+            tableName: "usage_plan_features";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "usage_plan_features";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Customer plans table - maps customers to their current plan
+ */
+declare const customerPlans: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "usage_customer_plans";
+    schema: undefined;
+    columns: {
+        customerId: drizzle_orm_pg_core.PgColumn<{
+            name: "customer_id";
+            tableName: "usage_customer_plans";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        planId: drizzle_orm_pg_core.PgColumn<{
+            name: "plan_id";
+            tableName: "usage_customer_plans";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        assignedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "assigned_at";
+            tableName: "usage_customer_plans";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "usage_customer_plans";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Customer access status table - tracks access status for each customer
+ */
+declare const customerAccessStatus: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "usage_customer_access_status";
+    schema: undefined;
+    columns: {
+        customerId: drizzle_orm_pg_core.PgColumn<{
+            name: "customer_id";
+            tableName: "usage_customer_access_status";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: drizzle_orm_pg_core.PgColumn<{
+            name: "status";
+            tableName: "usage_customer_access_status";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        reason: drizzle_orm_pg_core.PgColumn<{
+            name: "reason";
+            tableName: "usage_customer_access_status";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        suspensionDate: drizzle_orm_pg_core.PgColumn<{
+            name: "suspension_date";
+            tableName: "usage_customer_access_status";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        failedPaymentAttempts: drizzle_orm_pg_core.PgColumn<{
+            name: "failed_payment_attempts";
+            tableName: "usage_customer_access_status";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        gracePeriodEnd: drizzle_orm_pg_core.PgColumn<{
+            name: "grace_period_end";
+            tableName: "usage_customer_access_status";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "usage_customer_access_status";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Customer billing cycles table - tracks billing period for each customer
+ */
+declare const customerBillingCycles: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "usage_customer_billing_cycles";
+    schema: undefined;
+    columns: {
+        customerId: drizzle_orm_pg_core.PgColumn<{
+            name: "customer_id";
+            tableName: "usage_customer_billing_cycles";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        periodStart: drizzle_orm_pg_core.PgColumn<{
+            name: "period_start";
+            tableName: "usage_customer_billing_cycles";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        periodEnd: drizzle_orm_pg_core.PgColumn<{
+            name: "period_end";
+            tableName: "usage_customer_billing_cycles";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "usage_customer_billing_cycles";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Usage events table - raw usage event log
+ */
+declare const usageEvents: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "usage_events";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "usage_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tenantId: drizzle_orm_pg_core.PgColumn<{
+            name: "tenant_id";
+            tableName: "usage_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        customerId: drizzle_orm_pg_core.PgColumn<{
+            name: "customer_id";
+            tableName: "usage_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subscriptionId: drizzle_orm_pg_core.PgColumn<{
+            name: "subscription_id";
+            tableName: "usage_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        featureKey: drizzle_orm_pg_core.PgColumn<{
+            name: "feature_key";
+            tableName: "usage_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        quantity: drizzle_orm_pg_core.PgColumn<{
+            name: "quantity";
+            tableName: "usage_events";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        timestamp: drizzle_orm_pg_core.PgColumn<{
+            name: "timestamp";
+            tableName: "usage_events";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "usage_events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        idempotencyKey: drizzle_orm_pg_core.PgColumn<{
+            name: "idempotency_key";
+            tableName: "usage_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Usage aggregates table - pre-computed usage summaries for performance
+ */
+declare const usageAggregates: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "usage_aggregates";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "usage_aggregates";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tenantId: drizzle_orm_pg_core.PgColumn<{
+            name: "tenant_id";
+            tableName: "usage_aggregates";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        customerId: drizzle_orm_pg_core.PgColumn<{
+            name: "customer_id";
+            tableName: "usage_aggregates";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subscriptionId: drizzle_orm_pg_core.PgColumn<{
+            name: "subscription_id";
+            tableName: "usage_aggregates";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        featureKey: drizzle_orm_pg_core.PgColumn<{
+            name: "feature_key";
+            tableName: "usage_aggregates";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        periodStart: drizzle_orm_pg_core.PgColumn<{
+            name: "period_start";
+            tableName: "usage_aggregates";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        periodEnd: drizzle_orm_pg_core.PgColumn<{
+            name: "period_end";
+            tableName: "usage_aggregates";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        periodType: drizzle_orm_pg_core.PgColumn<{
+            name: "period_type";
+            tableName: "usage_aggregates";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        totalQuantity: drizzle_orm_pg_core.PgColumn<{
+            name: "total_quantity";
+            tableName: "usage_aggregates";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventCount: drizzle_orm_pg_core.PgColumn<{
+            name: "event_count";
+            tableName: "usage_aggregates";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastUpdated: drizzle_orm_pg_core.PgColumn<{
+            name: "last_updated";
+            tableName: "usage_aggregates";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Usage alerts table - tracks quota threshold alerts
+ */
+declare const usageAlerts: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "usage_alerts";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "usage_alerts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tenantId: drizzle_orm_pg_core.PgColumn<{
+            name: "tenant_id";
+            tableName: "usage_alerts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        customerId: drizzle_orm_pg_core.PgColumn<{
+            name: "customer_id";
+            tableName: "usage_alerts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subscriptionId: drizzle_orm_pg_core.PgColumn<{
+            name: "subscription_id";
+            tableName: "usage_alerts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        featureKey: drizzle_orm_pg_core.PgColumn<{
+            name: "feature_key";
+            tableName: "usage_alerts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        thresholdPercent: drizzle_orm_pg_core.PgColumn<{
+            name: "threshold_percent";
+            tableName: "usage_alerts";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: drizzle_orm_pg_core.PgColumn<{
+            name: "status";
+            tableName: "usage_alerts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currentUsage: drizzle_orm_pg_core.PgColumn<{
+            name: "current_usage";
+            tableName: "usage_alerts";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        limit: drizzle_orm_pg_core.PgColumn<{
+            name: "limit";
+            tableName: "usage_alerts";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        triggeredAt: drizzle_orm_pg_core.PgColumn<{
+            name: "triggered_at";
+            tableName: "usage_alerts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        acknowledgedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "acknowledged_at";
+            tableName: "usage_alerts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        resolvedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "resolved_at";
+            tableName: "usage_alerts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "usage_alerts";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "usage_alerts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+type Plan = typeof plans.$inferSelect;
+type NewPlan = typeof plans.$inferInsert;
+type PlanFeature = typeof planFeatures.$inferSelect;
+type NewPlanFeature = typeof planFeatures.$inferInsert;
+type CustomerPlan = typeof customerPlans.$inferSelect;
+type NewCustomerPlan = typeof customerPlans.$inferInsert;
+type CustomerAccessStatusRow = typeof customerAccessStatus.$inferSelect;
+type NewCustomerAccessStatus = typeof customerAccessStatus.$inferInsert;
+type CustomerBillingCycle = typeof customerBillingCycles.$inferSelect;
+type NewCustomerBillingCycle = typeof customerBillingCycles.$inferInsert;
+type UsageEventRow = typeof usageEvents.$inferSelect;
+type NewUsageEvent = typeof usageEvents.$inferInsert;
+type UsageAggregateRow = typeof usageAggregates.$inferSelect;
+type NewUsageAggregate = typeof usageAggregates.$inferInsert;
+type UsageAlertRow = typeof usageAlerts.$inferSelect;
+type NewUsageAlert = typeof usageAlerts.$inferInsert;
+
+type schema_CustomerAccessStatusRow = CustomerAccessStatusRow;
+type schema_CustomerBillingCycle = CustomerBillingCycle;
+type schema_CustomerPlan = CustomerPlan;
+type schema_NewCustomerAccessStatus = NewCustomerAccessStatus;
+type schema_NewCustomerBillingCycle = NewCustomerBillingCycle;
+type schema_NewCustomerPlan = NewCustomerPlan;
+type schema_NewPlan = NewPlan;
+type schema_NewPlanFeature = NewPlanFeature;
+type schema_NewUsageAggregate = NewUsageAggregate;
+type schema_NewUsageAlert = NewUsageAlert;
+type schema_NewUsageEvent = NewUsageEvent;
+type schema_Plan = Plan;
+type schema_PlanFeature = PlanFeature;
+type schema_UsageAggregateRow = UsageAggregateRow;
+type schema_UsageAlertRow = UsageAlertRow;
+type schema_UsageEventRow = UsageEventRow;
+declare const schema_customerAccessStatus: typeof customerAccessStatus;
+declare const schema_customerBillingCycles: typeof customerBillingCycles;
+declare const schema_customerPlans: typeof customerPlans;
+declare const schema_planFeatures: typeof planFeatures;
+declare const schema_plans: typeof plans;
+declare const schema_usageAggregates: typeof usageAggregates;
+declare const schema_usageAlerts: typeof usageAlerts;
+declare const schema_usageEvents: typeof usageEvents;
+declare namespace schema {
+  export { type schema_CustomerAccessStatusRow as CustomerAccessStatusRow, type schema_CustomerBillingCycle as CustomerBillingCycle, type schema_CustomerPlan as CustomerPlan, type schema_NewCustomerAccessStatus as NewCustomerAccessStatus, type schema_NewCustomerBillingCycle as NewCustomerBillingCycle, type schema_NewCustomerPlan as NewCustomerPlan, type schema_NewPlan as NewPlan, type schema_NewPlanFeature as NewPlanFeature, type schema_NewUsageAggregate as NewUsageAggregate, type schema_NewUsageAlert as NewUsageAlert, type schema_NewUsageEvent as NewUsageEvent, type schema_Plan as Plan, type schema_PlanFeature as PlanFeature, type schema_UsageAggregateRow as UsageAggregateRow, type schema_UsageAlertRow as UsageAlertRow, type schema_UsageEventRow as UsageEventRow, schema_customerAccessStatus as customerAccessStatus, schema_customerBillingCycles as customerBillingCycles, schema_customerPlans as customerPlans, schema_planFeatures as planFeatures, schema_plans as plans, schema_usageAggregates as usageAggregates, schema_usageAlerts as usageAlerts, schema_usageEvents as usageEvents };
+}
+
+/**
+ * @parsrun/payments - Quota Manager
+ * Handles quota checking and enforcement
+ */
+
+/**
+ * Quota Manager
+ * Handles checking and enforcing usage quotas
+ */
+declare class QuotaManager {
+    private readonly storage;
+    private readonly logger;
+    private readonly softLimits;
+    private readonly gracePercent;
+    private readonly overageAllowedFeatures;
+    private readonly onOverage?;
+    constructor(config: QuotaManagerConfig);
+    /**
+     * Check if overage is allowed for a feature
+     */
+    private isOverageAllowed;
+    /**
+     * Check if quota allows the requested quantity
+     */
+    checkQuota(customerId: string, featureKey: string, requestedQuantity?: number): Promise<QuotaCheckResult>;
+    /**
+     * Enforce quota - throws if exceeded
+     */
+    enforceQuota(customerId: string, featureKey: string, requestedQuantity?: number): Promise<void>;
+    /**
+     * Get quota status for a feature
+     */
+    getQuotaStatus(customerId: string, featureKey: string): Promise<QuotaStatus>;
+    /**
+     * Get all quota statuses for a customer
+     */
+    getAllQuotas(customerId: string): Promise<QuotaStatus[]>;
+    /**
+     * Check if any quota is exceeded
+     */
+    hasExceededQuotas(customerId: string): Promise<boolean>;
+    /**
+     * Get exceeded quotas
+     */
+    getExceededQuotas(customerId: string): Promise<QuotaStatus[]>;
+}
+/**
+ * Create quota manager
+ */
+declare function createQuotaManager(config: QuotaManagerConfig): QuotaManager;
+
+/**
+ * @parsrun/payments - Usage Tracker
+ * Handles recording and tracking usage events
+ */
+
+/**
+ * Usage tracker configuration
+ */
+interface UsageTrackerConfig {
+    storage: UsageStorage;
+    logger?: BillingLogger;
+    /** Update aggregates immediately on each event (default: true) */
+    aggregateOnRecord?: boolean;
+    /** Alert thresholds as percentages (default: [80, 100]) */
+    alertThresholds?: number[];
+    /** Callback when threshold is reached */
+    onThresholdReached?: (alert: UsageAlert) => void | Promise<void>;
+}
+/**
+ * Usage Tracker
+ * Records usage events and maintains aggregates
+ */
+declare class UsageTracker {
+    private readonly storage;
+    private readonly logger;
+    private readonly aggregateOnRecord;
+    private readonly alertThresholds;
+    private readonly onThresholdReached?;
+    constructor(config: UsageTrackerConfig);
+    /**
+     * Track a usage event
+     */
+    trackUsage(options: TrackUsageOptions): Promise<UsageEvent>;
+    /**
+     * Track multiple usage events
+     */
+    trackBatch(events: TrackUsageOptions[]): Promise<UsageEvent[]>;
+    /**
+     * Update aggregates for an event
+     */
+    private updateAggregates;
+    /**
+     * Check thresholds and create alerts if needed
+     */
+    private checkThresholds;
+    /**
+     * Get usage for a customer
+     */
+    getUsage(customerId: string, featureKey: string, periodType?: PeriodType): Promise<number>;
+    /**
+     * Get usage aggregates
+     */
+    getAggregates(customerId: string, featureKey: string, periodType: PeriodType, startDate?: Date, endDate?: Date): Promise<UsageAggregate[]>;
+    /**
+     * Force aggregate recalculation for a period
+     */
+    recalculateAggregates(customerId: string, featureKey: string, periodType: PeriodType, periodStart: Date): Promise<UsageAggregate>;
+}
+/**
+ * Create usage tracker
+ */
+declare function createUsageTracker(config: UsageTrackerConfig): UsageTracker;
+
+/**
+ * @parsrun/payments - Subscription Lifecycle Hooks
+ * Event-driven subscription lifecycle management
+ */
+
+/**
+ * Subscription Lifecycle
+ * Manages subscription event handlers
+ */
+declare class SubscriptionLifecycle {
+    private readonly handlers;
+    private readonly logger;
+    constructor(logger?: BillingLogger);
+    /**
+     * Register an event handler
+     */
+    on(event: SubscriptionEventType | "*", handler: SubscriptionHandler): this;
+    /**
+     * Remove an event handler
+     */
+    off(event: SubscriptionEventType | "*", handler: SubscriptionHandler): this;
+    /**
+     * Emit an event to all handlers
+     */
+    emit(event: SubscriptionEvent): Promise<void>;
+    /**
+     * Check if there are handlers for an event
+     */
+    hasHandlers(event: SubscriptionEventType | "*"): boolean;
+    /**
+     * Get handler count for an event
+     */
+    handlerCount(event: SubscriptionEventType | "*"): number;
+    /**
+     * Clear all handlers
+     */
+    clear(): void;
+    /**
+     * Handle subscription created
+     */
+    onCreated(handler: SubscriptionHandler): this;
+    /**
+     * Handle subscription activated
+     */
+    onActivated(handler: SubscriptionHandler): this;
+    /**
+     * Handle subscription updated
+     */
+    onUpdated(handler: SubscriptionHandler): this;
+    /**
+     * Handle plan changed
+     */
+    onPlanChanged(handler: SubscriptionHandler): this;
+    /**
+     * Handle subscription canceled
+     */
+    onCanceled(handler: SubscriptionHandler): this;
+    /**
+     * Handle subscription expired
+     */
+    onExpired(handler: SubscriptionHandler): this;
+    /**
+     * Handle subscription renewed
+     */
+    onRenewed(handler: SubscriptionHandler): this;
+    /**
+     * Handle trial started
+     */
+    onTrialStarted(handler: SubscriptionHandler): this;
+    /**
+     * Handle trial ended
+     */
+    onTrialEnded(handler: SubscriptionHandler): this;
+    /**
+     * Handle payment failed
+     */
+    onPaymentFailed(handler: SubscriptionHandler): this;
+    /**
+     * Handle payment succeeded
+     */
+    onPaymentSucceeded(handler: SubscriptionHandler): this;
+    /**
+     * Handle period reset
+     */
+    onPeriodReset(handler: SubscriptionHandler): this;
+    /**
+     * Handle all events
+     */
+    onAll(handler: SubscriptionHandler): this;
+}
+/**
+ * Create subscription lifecycle manager
+ */
+declare function createSubscriptionLifecycle(logger?: BillingLogger): SubscriptionLifecycle;
+
+/**
+ * Usage Service
+ *
+ * High-level API for usage-based billing:
+ * - Track usage events
+ * - Check and enforce quotas
+ * - Manage subscription lifecycle
+ * - Generate usage reports
+ *
+ * @example
+ * ```typescript
+ * const usageService = createUsageService({
+ *   storage: createMemoryUsageStorage(),
+ *   alertThresholds: [80, 100],
+ *   onThresholdReached: async (alert) => {
+ *     await sendEmail(alert.customerId, "usage-warning");
+ *   },
+ * });
+ *
+ * // Track usage
+ * await usageService.trackUsage({
+ *   tenantId: "tenant_123",
+ *   customerId: "cus_456",
+ *   featureKey: "api_calls",
+ *   quantity: 1,
+ * });
+ *
+ * // Check quota
+ * const quota = await usageService.getQuotaStatus("cus_456", "api_calls");
+ * if (quota.isExceeded) {
+ *   throw new Error("Quota exceeded");
+ * }
+ *
+ * // Lifecycle hooks
+ * usageService.onPlanChanged(async (event) => {
+ *   console.log(`Plan changed from ${event.previousPlan?.name} to ${event.newPlan?.name}`);
+ * });
+ * ```
+ */
+declare class UsageService {
+    private readonly storage;
+    private readonly logger;
+    private readonly quotaManager;
+    private readonly usageTracker;
+    private readonly lifecycle;
+    private readonly limitExceededHandler?;
+    private readonly resetPeriod;
+    private readonly autoResetOnRenewal;
+    private readonly paymentGraceDays;
+    private readonly maxFailedPayments;
+    private readonly accessStatusChangedHandler?;
+    private readonly periodResetHandler?;
+    constructor(config: UsageServiceConfig);
+    /**
+     * Track a usage event
+     */
+    trackUsage(options: TrackUsageOptions): Promise<UsageEvent>;
+    /**
+     * Track multiple usage events
+     */
+    trackBatch(events: TrackUsageOptions[]): Promise<UsageEvent[]>;
+    /**
+     * Get current usage for a feature
+     */
+    getUsage(customerId: string, featureKey: string, periodType?: PeriodType): Promise<number>;
+    /**
+     * Get usage aggregates
+     */
+    getAggregates(customerId: string, options?: GetUsageOptions): Promise<UsageAggregate[]>;
+    /**
+     * Check if quota allows the requested quantity
+     */
+    checkQuota(customerId: string, featureKey: string, quantity?: number): Promise<QuotaCheckResult>;
+    /**
+     * Enforce quota - throws if exceeded
+     */
+    enforceQuota(customerId: string, featureKey: string, quantity?: number): Promise<void>;
+    /**
+     * Get quota status for a feature
+     */
+    getQuotaStatus(customerId: string, featureKey: string): Promise<QuotaStatus>;
+    /**
+     * Get all quota statuses for a customer
+     */
+    getAllQuotas(customerId: string): Promise<QuotaStatus[]>;
+    /**
+     * Check if any quota is exceeded
+     */
+    hasExceededQuotas(customerId: string): Promise<boolean>;
+    /**
+     * Get customer's current plan
+     */
+    getCustomerPlan(customerId: string): Promise<Plan$1 | null>;
+    /**
+     * Set customer's plan
+     */
+    setCustomerPlan(customerId: string, planId: string): Promise<void>;
+    /**
+     * Get plan by ID
+     */
+    getPlan(planId: string): Promise<Plan$1 | null>;
+    /**
+     * Get plan by name
+     */
+    getPlanByName(name: string): Promise<Plan$1 | null>;
+    /**
+     * List all plans
+     */
+    listPlans(options?: {
+        activeOnly?: boolean;
+    }): Promise<Plan$1[]>;
+    /**
+     * Get plan features
+     */
+    getPlanFeatures(planId: string): Promise<PlanFeature$1[]>;
+    /**
+     * Register a subscription event handler
+     */
+    on(event: SubscriptionEventType | "*", handler: SubscriptionHandler): this;
+    /**
+     * Remove a subscription event handler
+     */
+    off(event: SubscriptionEventType | "*", handler: SubscriptionHandler): this;
+    /**
+     * Handle subscription created
+     */
+    onSubscriptionCreated(handler: SubscriptionHandler): this;
+    /**
+     * Handle subscription updated
+     */
+    onSubscriptionUpdated(handler: SubscriptionHandler): this;
+    /**
+     * Handle subscription canceled
+     */
+    onSubscriptionCanceled(handler: SubscriptionHandler): this;
+    /**
+     * Handle plan changed
+     */
+    onPlanChanged(handler: SubscriptionHandler): this;
+    /**
+     * Handle subscription renewed
+     */
+    onRenewed(handler: SubscriptionHandler): this;
+    /**
+     * Handle payment failed
+     */
+    onPaymentFailed(handler: SubscriptionHandler): this;
+    /**
+     * Handle period reset
+     */
+    onPeriodReset(handler: SubscriptionHandler): this;
+    /**
+     * Get the lifecycle manager for advanced usage
+     */
+    get lifecycleManager(): SubscriptionLifecycle;
+    /**
+     * Get active alerts for a customer
+     */
+    getActiveAlerts(customerId: string): Promise<UsageAlert[]>;
+    /**
+     * Acknowledge an alert
+     */
+    acknowledgeAlert(alertId: string): Promise<void>;
+    /**
+     * Resolve an alert
+     */
+    resolveAlert(alertId: string): Promise<void>;
+    /**
+     * Reset usage for a customer
+     * Typically called on subscription renewal
+     */
+    resetUsage(customerId: string, featureKeys?: string[]): Promise<void>;
+    /**
+     * Get the period start date based on reset period setting
+     */
+    private getResetPeriodStart;
+    /**
+     * Get feature keys for a customer's plan
+     */
+    private getCustomerFeatureKeys;
+    /**
+     * Check if auto-reset on renewal is enabled
+     */
+    get autoResetEnabled(): boolean;
+    /**
+     * Get current reset period setting
+     */
+    get currentResetPeriod(): ResetPeriod;
+    /**
+     * Get customer access status
+     */
+    getAccessStatus(customerId: string): Promise<AccessStatusInfo>;
+    /**
+     * Set customer access status
+     */
+    setAccessStatus(customerId: string, status: AccessStatus, options?: {
+        reason?: string;
+        suspensionDate?: Date;
+        failedPaymentAttempts?: number;
+        gracePeriodEnd?: Date;
+    }): Promise<void>;
+    /**
+     * Handle payment failure - update access status
+     */
+    handlePaymentFailure(customerId: string): Promise<void>;
+    /**
+     * Handle successful payment - restore access status
+     */
+    handlePaymentSuccess(customerId: string): Promise<void>;
+    /**
+     * Check if customer has access (not suspended/canceled)
+     */
+    hasAccess(customerId: string): Promise<boolean>;
+    /**
+     * Check if customer is in grace period
+     */
+    isInGracePeriod(customerId: string): Promise<boolean>;
+    /**
+     * Set customer billing cycle
+     */
+    setBillingCycle(customerId: string, start: Date, end: Date): Promise<void>;
+    /**
+     * Get customer billing cycle
+     */
+    getBillingCycle(customerId: string): Promise<{
+        start: Date;
+        end: Date;
+    } | null>;
+    /**
+     * Get the underlying storage
+     */
+    get storageBackend(): UsageStorage;
+    /**
+     * Get the quota manager
+     */
+    get quotas(): QuotaManager;
+    /**
+     * Get the usage tracker
+     */
+    get tracker(): UsageTracker;
+}
+/**
+ * Create usage service
+ */
+declare function createUsageService(config: UsageServiceConfig): UsageService;
+
+/**
+ * @parsrun/payments - Billing Integration
+ * Connects BillingService webhooks to UsageService lifecycle
+ */
+
+/**
+ * Billing integration configuration
+ */
+interface BillingIntegrationConfig {
+    /** Billing service instance */
+    billing: BillingService;
+    /** Usage service instance */
+    usage: UsageService;
+    /** Logger */
+    logger?: BillingLogger;
+    /** Auto-initialize customer plan on subscription creation */
+    autoInitializePlan?: boolean;
+    /**
+     * Auto-reset quotas on subscription renewal
+     * Default: true (uses UsageService.autoResetOnRenewal setting)
+     */
+    autoResetOnRenewal?: boolean;
+    /**
+     * Auto-update access status based on payment events
+     * Default: true
+     */
+    autoManageAccessStatus?: boolean;
+    /** Plan ID resolver - maps payment provider price IDs to internal plan IDs */
+    resolvePlanId?: (priceId: string, provider: PaymentProviderType) => string | Promise<string>;
+    /** Custom event handlers */
+    onSubscriptionCreated?: (event: SubscriptionEvent) => void | Promise<void>;
+    onSubscriptionCanceled?: (event: SubscriptionEvent) => void | Promise<void>;
+    onSubscriptionRenewed?: (event: SubscriptionEvent) => void | Promise<void>;
+    onPlanChanged?: (event: SubscriptionEvent) => void | Promise<void>;
+    onPaymentFailed?: (event: SubscriptionEvent) => void | Promise<void>;
+}
+/**
+ * Billing Integration
+ *
+ * Connects BillingService webhooks to UsageService lifecycle events.
+ * This enables automatic:
+ * - Customer plan initialization on subscription creation
+ * - Plan updates when subscription changes
+ * - Usage reset on subscription renewal
+ * - Lifecycle event emission
+ *
+ * @example
+ * ```typescript
+ * import { createBillingService, createUsageService, integrateBillingWithUsage } from "@parsrun/payments";
+ *
+ * const billing = createBillingService({
+ *   providers: { default: stripeProvider },
+ * });
+ *
+ * const usage = createUsageService({
+ *   storage: createMemoryUsageStorage(),
+ * });
+ *
+ * // Connect them
+ * const integration = integrateBillingWithUsage({
+ *   billing,
+ *   usage,
+ *   autoInitializePlan: true,
+ *   resolvePlanId: (priceId) => {
+ *     // Map Stripe price IDs to your internal plan IDs
+ *     const mapping: Record<string, string> = {
+ *       "price_starter": "starter",
+ *       "price_pro": "pro",
+ *       "price_enterprise": "enterprise",
+ *     };
+ *     return mapping[priceId] ?? "free";
+ *   },
+ * });
+ *
+ * // Now subscription webhooks automatically update usage quotas
+ * ```
+ */
+declare class BillingIntegration {
+    private readonly billing;
+    private readonly usage;
+    private readonly logger;
+    private readonly autoInitializePlan;
+    private readonly autoResetOnRenewal;
+    private readonly autoManageAccessStatus;
+    private readonly resolvePlanId;
+    private readonly config;
+    constructor(config: BillingIntegrationConfig);
+    /**
+     * Setup webhook handlers on billing service
+     */
+    private setupWebhookHandlers;
+    /**
+     * Handle subscription created webhook
+     */
+    private handleSubscriptionCreated;
+    /**
+     * Handle subscription updated webhook
+     */
+    private handleSubscriptionUpdated;
+    /**
+     * Handle subscription canceled webhook
+     */
+    private handleSubscriptionCanceled;
+    /**
+     * Handle invoice paid webhook (renewal)
+     */
+    private handleInvoicePaid;
+    /**
+     * Handle payment failed webhook
+     */
+    private handlePaymentFailed;
+    /**
+     * Manually sync customer plan from billing provider
+     */
+    syncCustomerPlan(customerId: string, provider?: PaymentProviderType): Promise<Plan$1 | null>;
+}
+/**
+ * Create billing integration
+ *
+ * Connects BillingService webhooks to UsageService lifecycle events.
+ *
+ * @example
+ * ```typescript
+ * const integration = integrateBillingWithUsage({
+ *   billing,
+ *   usage,
+ *   autoInitializePlan: true,
+ *   resolvePlanId: (priceId) => priceMapping[priceId] ?? "free",
+ * });
+ * ```
+ */
+declare function integrateBillingWithUsage(config: BillingIntegrationConfig): BillingIntegration;
+/**
+ * Alias for integrateBillingWithUsage
+ */
+declare const createBillingIntegration: typeof integrateBillingWithUsage;
+
+/**
+ * @parsrun/payments - Usage Meter
+ * Buffers usage events and syncs to payment provider
+ *
+ * This solves the problem of:
+ * - Not hitting provider API limits with per-request calls
+ * - Reducing latency by batching usage reports
+ * - Ensuring reliable usage reporting with retry logic
+ */
+
+/**
+ * Usage record to report to provider
+ */
+interface UsageRecord {
+    /** Subscription item ID (Stripe) or subscription ID (Paddle) */
+    subscriptionItemId: string;
+    /** Usage quantity */
+    quantity: number;
+    /** Timestamp of usage (defaults to now) */
+    timestamp?: Date;
+    /** Action: increment (add to existing) or set (replace) */
+    action?: "increment" | "set";
+    /** Idempotency key to prevent duplicates */
+    idempotencyKey?: string;
+}
+/**
+ * Buffered usage record with metadata
+ */
+interface BufferedRecord {
+    record: UsageRecord;
+    customerId: string;
+    featureKey: string;
+    addedAt: Date;
+    attempts: number;
+}
+/**
+ * Usage reporter interface - implemented by providers
+ */
+interface UsageReporter {
+    /**
+     * Report usage to the payment provider
+     */
+    reportUsage(record: UsageRecord): Promise<void>;
+    /**
+     * Report multiple usage records (batch)
+     */
+    reportUsageBatch?(records: UsageRecord[]): Promise<void>;
+    /**
+     * Get subscription item ID for a subscription and price
+     */
+    getSubscriptionItemId?(subscriptionId: string, priceId: string): Promise<string | null>;
+}
+/**
+ * Sync strategy configuration
+ */
+type SyncStrategy = {
+    type: "interval";
+    intervalMs: number;
+} | {
+    type: "threshold";
+    maxRecords: number;
+    maxAgeMs: number;
+} | {
+    type: "manual";
+};
+/**
+ * Usage meter configuration
+ */
+interface UsageMeterConfig {
+    /** Usage reporter (provider with reportUsage method) */
+    reporter: UsageReporter;
+    /** Provider type for logging */
+    providerType: PaymentProviderType;
+    /** Sync strategy */
+    strategy: SyncStrategy;
+    /** Logger */
+    logger?: BillingLogger;
+    /** Max retry attempts for failed syncs */
+    maxRetries?: number;
+    /** Retry delay in ms */
+    retryDelayMs?: number;
+    /** Callback on successful sync */
+    onSyncSuccess?: (count: number) => void;
+    /** Callback on sync failure */
+    onSyncError?: (error: Error, records: BufferedRecord[]) => void;
+    /** Callback when buffer is getting full (>80%) */
+    onBufferWarning?: (size: number, maxSize: number) => void;
+    /** Maximum buffer size before forcing sync */
+    maxBufferSize?: number;
+}
+/**
+ * Usage Meter
+ *
+ * Buffers usage events and syncs to payment provider periodically.
+ * Supports multiple sync strategies:
+ * - interval: Sync every N milliseconds
+ * - threshold: Sync when buffer reaches N records or records are older than N ms
+ * - manual: Only sync when explicitly called
+ *
+ * @example
+ * ```typescript
+ * import { createUsageMeter } from "@parsrun/payments";
+ *
+ * const meter = createUsageMeter({
+ *   reporter: stripeProvider, // Provider must implement UsageReporter
+ *   providerType: "stripe",
+ *   strategy: { type: "interval", intervalMs: 60000 }, // Sync every minute
+ * });
+ *
+ * // Record usage (buffered, not sent immediately)
+ * meter.record({
+ *   customerId: "cus_123",
+ *   featureKey: "api_calls",
+ *   subscriptionItemId: "si_xxx",
+ *   quantity: 1,
+ * });
+ *
+ * // Force immediate sync
+ * await meter.flush();
+ *
+ * // Cleanup when done
+ * meter.stop();
+ * ```
+ */
+declare class UsageMeter {
+    private readonly reporter;
+    private readonly providerType;
+    private readonly logger;
+    private readonly strategy;
+    private readonly maxRetries;
+    private readonly retryDelayMs;
+    private readonly maxBufferSize;
+    private readonly config;
+    private buffer;
+    private intervalId;
+    private isSyncing;
+    private isRunning;
+    constructor(config: UsageMeterConfig);
+    /**
+     * Start the meter (auto-sync based on strategy)
+     */
+    start(): void;
+    /**
+     * Stop the meter
+     */
+    stop(): void;
+    /**
+     * Record usage (buffered)
+     */
+    record(options: {
+        customerId: string;
+        featureKey: string;
+        subscriptionItemId: string;
+        quantity: number;
+        timestamp?: Date;
+        action?: "increment" | "set";
+        idempotencyKey?: string;
+    }): void;
+    /**
+     * Check threshold and trigger sync if needed
+     */
+    private checkThreshold;
+    /**
+     * Flush buffer to provider
+     */
+    flush(): Promise<number>;
+    /**
+     * Aggregate records by subscription item ID
+     */
+    private aggregateRecords;
+    /**
+     * Sync single record with retry
+     */
+    private syncWithRetry;
+    /**
+     * Delay helper
+     */
+    private delay;
+    /**
+     * Get buffer size
+     */
+    get bufferSize(): number;
+    /**
+     * Get sync status
+     */
+    get syncing(): boolean;
+    /**
+     * Get running status
+     */
+    get running(): boolean;
+    /**
+     * Get buffer contents (for debugging)
+     */
+    getBuffer(): ReadonlyArray<BufferedRecord>;
+}
+/**
+ * Create usage meter
+ */
+declare function createUsageMeter(config: UsageMeterConfig): UsageMeter;
+/**
+ * Subscription item mapping
+ * Maps (customerId, featureKey) to subscriptionItemId
+ */
+interface SubscriptionItemMapping {
+    customerId: string;
+    featureKey: string;
+    subscriptionId: string;
+    subscriptionItemId: string;
+    priceId: string;
+    createdAt: Date;
+}
+/**
+ * Subscription item resolver configuration
+ */
+interface SubscriptionItemResolverConfig {
+    /** Reporter to fetch subscription items */
+    reporter: UsageReporter;
+    /** Cache TTL in ms (default: 1 hour) */
+    cacheTtlMs?: number;
+    /** Logger */
+    logger?: BillingLogger;
+}
+/**
+ * Subscription Item Resolver
+ *
+ * Resolves and caches subscription item IDs.
+ * Stripe requires subscription_item_id for metered billing,
+ * this resolver handles the lookup and caching.
+ */
+declare class SubscriptionItemResolver {
+    private readonly reporter;
+    private readonly cacheTtlMs;
+    private readonly logger;
+    private cache;
+    constructor(config: SubscriptionItemResolverConfig);
+    /**
+     * Get subscription item ID
+     */
+    resolve(subscriptionId: string, priceId: string): Promise<string | null>;
+    /**
+     * Set cache entry manually (useful when creating subscriptions)
+     */
+    setCache(subscriptionId: string, priceId: string, itemId: string): void;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache size
+     */
+    get cacheSize(): number;
+}
+/**
+ * Create subscription item resolver
+ */
+declare function createSubscriptionItemResolver(config: SubscriptionItemResolverConfig): SubscriptionItemResolver;
+
+export { type AccessStatus, type AccessStatusInfo, type AlertStatus, BillingIntegration, type BillingIntegrationConfig, type BillingInterval, type BillingLogger, type DrizzleDb, DrizzleUsageStorage, type DrizzleUsageStorageConfig, type GetUsageOptions, type LimitPeriod, MemoryUsageStorage, type PeriodType, type Plan$1 as Plan, type PlanFeature$1 as PlanFeature, type PlanTier, type QuotaCheckResult, QuotaExceededError, QuotaManager, type QuotaManagerConfig, type QuotaStatus, type ResetPeriod, type SubscriptionEvent, type SubscriptionEventType, type SubscriptionHandler, type SubscriptionItemMapping, SubscriptionItemResolver, type SubscriptionItemResolverConfig, SubscriptionLifecycle, type SyncStrategy, type TrackUsageOptions, type UsageAggregate, type UsageAlert, UsageError, type UsageErrorCode, UsageErrorCodes, type UsageEvent, UsageMeter, type UsageMeterConfig, type UsageRecord, type UsageReporter, UsageService, type UsageServiceConfig, type UsageStorage, UsageTracker, type UsageTrackerConfig, type UsageWebhookEventType, createBillingIntegration, createDrizzleUsageStorage, createMemoryUsageStorage, createQuotaManager, createSubscriptionItemResolver, createSubscriptionLifecycle, createUsageMeter, createUsageService, createUsageTracker, integrateBillingWithUsage, schema as usageSchema };