@t402/streaming-payments 1.0.0-beta.1

package/dist/streaming/index.d.ts

@@ -0,0 +1,1004 @@
+import { z } from 'zod';
+
+/**
+ * Stream state
+ */
+declare const StreamState: z.ZodEnum<["idle", "active", "paused", "completed", "cancelled"]>;
+type StreamState = z.infer<typeof StreamState>;
+/**
+ * Rate type
+ */
+declare const RateType: z.ZodEnum<["fixed", "variable", "tiered", "dynamic"]>;
+type RateType = z.infer<typeof RateType>;
+/**
+ * Stream rate configuration
+ */
+declare const StreamRate: z.ZodObject<{
+    type: z.ZodEnum<["fixed", "variable", "tiered", "dynamic"]>;
+    baseRate: z.ZodString;
+    minRate: z.ZodOptional<z.ZodString>;
+    maxRate: z.ZodOptional<z.ZodString>;
+    tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        threshold: z.ZodString;
+        rate: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        threshold: string;
+        rate: string;
+    }, {
+        threshold: string;
+        rate: string;
+    }>, "many">>;
+    adjustmentInterval: z.ZodOptional<z.ZodNumber>;
+    adjustmentFactor: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "fixed" | "variable" | "tiered" | "dynamic";
+    baseRate: string;
+    minRate?: string | undefined;
+    maxRate?: string | undefined;
+    tiers?: {
+        threshold: string;
+        rate: string;
+    }[] | undefined;
+    adjustmentInterval?: number | undefined;
+    adjustmentFactor?: number | undefined;
+}, {
+    type: "fixed" | "variable" | "tiered" | "dynamic";
+    baseRate: string;
+    minRate?: string | undefined;
+    maxRate?: string | undefined;
+    tiers?: {
+        threshold: string;
+        rate: string;
+    }[] | undefined;
+    adjustmentInterval?: number | undefined;
+    adjustmentFactor?: number | undefined;
+}>;
+type StreamRate = z.infer<typeof StreamRate>;
+/**
+ * Usage metrics
+ */
+declare const UsageMetrics: z.ZodObject<{
+    totalSeconds: z.ZodNumber;
+    totalAmount: z.ZodString;
+    averageRate: z.ZodString;
+    peakRate: z.ZodString;
+    startTime: z.ZodNumber;
+    endTime: z.ZodOptional<z.ZodNumber>;
+    hourly: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        hour: z.ZodNumber;
+        amount: z.ZodString;
+        seconds: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        amount: string;
+        hour: number;
+        seconds: number;
+    }, {
+        amount: string;
+        hour: number;
+        seconds: number;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    startTime: number;
+    totalSeconds: number;
+    totalAmount: string;
+    averageRate: string;
+    peakRate: string;
+    endTime?: number | undefined;
+    hourly?: {
+        amount: string;
+        hour: number;
+        seconds: number;
+    }[] | undefined;
+}, {
+    startTime: number;
+    totalSeconds: number;
+    totalAmount: string;
+    averageRate: string;
+    peakRate: string;
+    endTime?: number | undefined;
+    hourly?: {
+        amount: string;
+        hour: number;
+        seconds: number;
+    }[] | undefined;
+}>;
+type UsageMetrics = z.infer<typeof UsageMetrics>;
+/**
+ * Metering record
+ */
+declare const MeteringRecord: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    duration: z.ZodNumber;
+    amount: z.ZodString;
+    rate: z.ZodString;
+    cumulative: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    amount: string;
+    rate: string;
+    duration: number;
+    cumulative: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    timestamp: number;
+    amount: string;
+    rate: string;
+    duration: number;
+    cumulative: string;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+type MeteringRecord = z.infer<typeof MeteringRecord>;
+/**
+ * Billing period
+ */
+declare const BillingPeriod: z.ZodEnum<["realtime", "second", "minute", "hour", "day"]>;
+type BillingPeriod = z.infer<typeof BillingPeriod>;
+/**
+ * Billing configuration
+ */
+declare const BillingConfig: z.ZodObject<{
+    period: z.ZodEnum<["realtime", "second", "minute", "hour", "day"]>;
+    minimumCharge: z.ZodDefault<z.ZodString>;
+    roundingMode: z.ZodDefault<z.ZodEnum<["floor", "ceil", "round"]>>;
+    gracePeriod: z.ZodDefault<z.ZodNumber>;
+    invoiceInterval: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    gracePeriod: number;
+    period: "hour" | "realtime" | "second" | "minute" | "day";
+    minimumCharge: string;
+    roundingMode: "floor" | "ceil" | "round";
+    invoiceInterval?: number | undefined;
+}, {
+    period: "hour" | "realtime" | "second" | "minute" | "day";
+    gracePeriod?: number | undefined;
+    minimumCharge?: string | undefined;
+    roundingMode?: "floor" | "ceil" | "round" | undefined;
+    invoiceInterval?: number | undefined;
+}>;
+type BillingConfig = z.infer<typeof BillingConfig>;
+/**
+ * Invoice item
+ */
+declare const InvoiceItem: z.ZodObject<{
+    description: z.ZodString;
+    quantity: z.ZodNumber;
+    rate: z.ZodString;
+    amount: z.ZodString;
+    startTime: z.ZodNumber;
+    endTime: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    startTime: number;
+    amount: string;
+    rate: string;
+    endTime: number;
+    description: string;
+    quantity: number;
+}, {
+    startTime: number;
+    amount: string;
+    rate: string;
+    endTime: number;
+    description: string;
+    quantity: number;
+}>;
+type InvoiceItem = z.infer<typeof InvoiceItem>;
+/**
+ * Invoice
+ */
+declare const Invoice: z.ZodObject<{
+    id: z.ZodString;
+    channelId: z.ZodString;
+    payer: z.ZodString;
+    payee: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        quantity: z.ZodNumber;
+        rate: z.ZodString;
+        amount: z.ZodString;
+        startTime: z.ZodNumber;
+        endTime: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        startTime: number;
+        amount: string;
+        rate: string;
+        endTime: number;
+        description: string;
+        quantity: number;
+    }, {
+        startTime: number;
+        amount: string;
+        rate: string;
+        endTime: number;
+        description: string;
+        quantity: number;
+    }>, "many">;
+    subtotal: z.ZodString;
+    fees: z.ZodString;
+    total: z.ZodString;
+    currency: z.ZodString;
+    status: z.ZodEnum<["pending", "paid", "settled", "disputed"]>;
+    createdAt: z.ZodNumber;
+    dueAt: z.ZodOptional<z.ZodNumber>;
+    paidAt: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "paid" | "settled" | "disputed";
+    payer: string;
+    payee: string;
+    total: string;
+    channelId: string;
+    id: string;
+    createdAt: number;
+    items: {
+        startTime: number;
+        amount: string;
+        rate: string;
+        endTime: number;
+        description: string;
+        quantity: number;
+    }[];
+    subtotal: string;
+    fees: string;
+    currency: string;
+    dueAt?: number | undefined;
+    paidAt?: number | undefined;
+}, {
+    status: "pending" | "paid" | "settled" | "disputed";
+    payer: string;
+    payee: string;
+    total: string;
+    channelId: string;
+    id: string;
+    createdAt: number;
+    items: {
+        startTime: number;
+        amount: string;
+        rate: string;
+        endTime: number;
+        description: string;
+        quantity: number;
+    }[];
+    subtotal: string;
+    fees: string;
+    currency: string;
+    dueAt?: number | undefined;
+    paidAt?: number | undefined;
+}>;
+type Invoice = z.infer<typeof Invoice>;
+/**
+ * Stream session
+ */
+declare const StreamSession: z.ZodObject<{
+    id: z.ZodString;
+    channelId: z.ZodString;
+    state: z.ZodEnum<["idle", "active", "paused", "completed", "cancelled"]>;
+    rate: z.ZodObject<{
+        type: z.ZodEnum<["fixed", "variable", "tiered", "dynamic"]>;
+        baseRate: z.ZodString;
+        minRate: z.ZodOptional<z.ZodString>;
+        maxRate: z.ZodOptional<z.ZodString>;
+        tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            threshold: z.ZodString;
+            rate: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            threshold: string;
+            rate: string;
+        }, {
+            threshold: string;
+            rate: string;
+        }>, "many">>;
+        adjustmentInterval: z.ZodOptional<z.ZodNumber>;
+        adjustmentFactor: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "fixed" | "variable" | "tiered" | "dynamic";
+        baseRate: string;
+        minRate?: string | undefined;
+        maxRate?: string | undefined;
+        tiers?: {
+            threshold: string;
+            rate: string;
+        }[] | undefined;
+        adjustmentInterval?: number | undefined;
+        adjustmentFactor?: number | undefined;
+    }, {
+        type: "fixed" | "variable" | "tiered" | "dynamic";
+        baseRate: string;
+        minRate?: string | undefined;
+        maxRate?: string | undefined;
+        tiers?: {
+            threshold: string;
+            rate: string;
+        }[] | undefined;
+        adjustmentInterval?: number | undefined;
+        adjustmentFactor?: number | undefined;
+    }>;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    pausedAt: z.ZodOptional<z.ZodNumber>;
+    endedAt: z.ZodOptional<z.ZodNumber>;
+    totalDuration: z.ZodNumber;
+    totalAmount: z.ZodString;
+    meteringRecords: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodNumber;
+        duration: z.ZodNumber;
+        amount: z.ZodString;
+        rate: z.ZodString;
+        cumulative: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: number;
+        amount: string;
+        rate: string;
+        duration: number;
+        cumulative: string;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        timestamp: number;
+        amount: string;
+        rate: string;
+        duration: number;
+        cumulative: string;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">;
+    billingConfig: z.ZodObject<{
+        period: z.ZodEnum<["realtime", "second", "minute", "hour", "day"]>;
+        minimumCharge: z.ZodDefault<z.ZodString>;
+        roundingMode: z.ZodDefault<z.ZodEnum<["floor", "ceil", "round"]>>;
+        gracePeriod: z.ZodDefault<z.ZodNumber>;
+        invoiceInterval: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        gracePeriod: number;
+        period: "hour" | "realtime" | "second" | "minute" | "day";
+        minimumCharge: string;
+        roundingMode: "floor" | "ceil" | "round";
+        invoiceInterval?: number | undefined;
+    }, {
+        period: "hour" | "realtime" | "second" | "minute" | "day";
+        gracePeriod?: number | undefined;
+        minimumCharge?: string | undefined;
+        roundingMode?: "floor" | "ceil" | "round" | undefined;
+        invoiceInterval?: number | undefined;
+    }>;
+    invoices: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    channelId: string;
+    id: string;
+    state: "paused" | "idle" | "active" | "completed" | "cancelled";
+    rate: {
+        type: "fixed" | "variable" | "tiered" | "dynamic";
+        baseRate: string;
+        minRate?: string | undefined;
+        maxRate?: string | undefined;
+        tiers?: {
+            threshold: string;
+            rate: string;
+        }[] | undefined;
+        adjustmentInterval?: number | undefined;
+        adjustmentFactor?: number | undefined;
+    };
+    totalAmount: string;
+    totalDuration: number;
+    meteringRecords: {
+        timestamp: number;
+        amount: string;
+        rate: string;
+        duration: number;
+        cumulative: string;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    billingConfig: {
+        gracePeriod: number;
+        period: "hour" | "realtime" | "second" | "minute" | "day";
+        minimumCharge: string;
+        roundingMode: "floor" | "ceil" | "round";
+        invoiceInterval?: number | undefined;
+    };
+    invoices: string[];
+    pausedAt?: number | undefined;
+    startedAt?: number | undefined;
+    endedAt?: number | undefined;
+}, {
+    channelId: string;
+    id: string;
+    state: "paused" | "idle" | "active" | "completed" | "cancelled";
+    rate: {
+        type: "fixed" | "variable" | "tiered" | "dynamic";
+        baseRate: string;
+        minRate?: string | undefined;
+        maxRate?: string | undefined;
+        tiers?: {
+            threshold: string;
+            rate: string;
+        }[] | undefined;
+        adjustmentInterval?: number | undefined;
+        adjustmentFactor?: number | undefined;
+    };
+    totalAmount: string;
+    totalDuration: number;
+    meteringRecords: {
+        timestamp: number;
+        amount: string;
+        rate: string;
+        duration: number;
+        cumulative: string;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    billingConfig: {
+        period: "hour" | "realtime" | "second" | "minute" | "day";
+        gracePeriod?: number | undefined;
+        minimumCharge?: string | undefined;
+        roundingMode?: "floor" | "ceil" | "round" | undefined;
+        invoiceInterval?: number | undefined;
+    };
+    invoices: string[];
+    pausedAt?: number | undefined;
+    startedAt?: number | undefined;
+    endedAt?: number | undefined;
+}>;
+type StreamSession = z.infer<typeof StreamSession>;
+/**
+ * Rate adjustment request
+ */
+declare const RateAdjustmentRequest: z.ZodObject<{
+    sessionId: z.ZodString;
+    newRate: z.ZodString;
+    reason: z.ZodString;
+    effectiveFrom: z.ZodOptional<z.ZodNumber>;
+    signature: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    reason: string;
+    sessionId: string;
+    newRate: string;
+    signature?: string | undefined;
+    effectiveFrom?: number | undefined;
+}, {
+    reason: string;
+    sessionId: string;
+    newRate: string;
+    signature?: string | undefined;
+    effectiveFrom?: number | undefined;
+}>;
+type RateAdjustmentRequest = z.infer<typeof RateAdjustmentRequest>;
+/**
+ * Stream event
+ */
+declare const StreamEvent: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"started">;
+    sessionId: z.ZodString;
+    timestamp: z.ZodNumber;
+    rate: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "started";
+    timestamp: number;
+    rate: string;
+    sessionId: string;
+}, {
+    type: "started";
+    timestamp: number;
+    rate: string;
+    sessionId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"paused">;
+    sessionId: z.ZodString;
+    timestamp: z.ZodNumber;
+    totalStreamed: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "paused";
+    timestamp: number;
+    sessionId: string;
+    totalStreamed: string;
+}, {
+    type: "paused";
+    timestamp: number;
+    sessionId: string;
+    totalStreamed: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"resumed">;
+    sessionId: z.ZodString;
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "resumed";
+    timestamp: number;
+    sessionId: string;
+}, {
+    type: "resumed";
+    timestamp: number;
+    sessionId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"rate_changed">;
+    sessionId: z.ZodString;
+    timestamp: z.ZodNumber;
+    oldRate: z.ZodString;
+    newRate: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "rate_changed";
+    timestamp: number;
+    sessionId: string;
+    newRate: string;
+    oldRate: string;
+}, {
+    type: "rate_changed";
+    timestamp: number;
+    sessionId: string;
+    newRate: string;
+    oldRate: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"checkpoint">;
+    sessionId: z.ZodString;
+    timestamp: z.ZodNumber;
+    amount: z.ZodString;
+    checkpointId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "checkpoint";
+    timestamp: number;
+    amount: string;
+    sessionId: string;
+    checkpointId: string;
+}, {
+    type: "checkpoint";
+    timestamp: number;
+    amount: string;
+    sessionId: string;
+    checkpointId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"completed">;
+    sessionId: z.ZodString;
+    timestamp: z.ZodNumber;
+    totalAmount: z.ZodString;
+    totalDuration: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "completed";
+    timestamp: number;
+    totalAmount: string;
+    totalDuration: number;
+    sessionId: string;
+}, {
+    type: "completed";
+    timestamp: number;
+    totalAmount: string;
+    totalDuration: number;
+    sessionId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"cancelled">;
+    sessionId: z.ZodString;
+    timestamp: z.ZodNumber;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "cancelled";
+    timestamp: number;
+    reason: string;
+    sessionId: string;
+}, {
+    type: "cancelled";
+    timestamp: number;
+    reason: string;
+    sessionId: string;
+}>]>;
+type StreamEvent = z.infer<typeof StreamEvent>;
+
+/**
+ * Flow controller configuration
+ */
+interface FlowConfig {
+    updateInterval?: number;
+    bufferTime?: number;
+    autoCheckpoint?: boolean;
+    checkpointInterval?: number;
+}
+/**
+ * Flow controller for managing streaming sessions
+ */
+declare class FlowController {
+    private session;
+    private config;
+    private updateTimer?;
+    private checkpointTimer?;
+    private eventListeners;
+    private lastUpdateTime;
+    constructor(channelId: string, rate: StreamRate, billingConfig: BillingConfig, config?: FlowConfig);
+    /**
+     * Get current session state
+     */
+    getSession(): StreamSession;
+    /**
+     * Get current state
+     */
+    getState(): StreamState;
+    /**
+     * Start streaming
+     */
+    start(): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Pause streaming
+     */
+    pause(): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Resume streaming (alias for start when paused)
+     */
+    resume(): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Stop streaming (complete)
+     */
+    stop(): {
+        success: boolean;
+        error?: string;
+        finalAmount: string;
+    };
+    /**
+     * Cancel streaming
+     */
+    cancel(reason: string): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Get current streamed amount
+     */
+    getCurrentAmount(): string;
+    /**
+     * Get current rate
+     */
+    getCurrentRate(): string;
+    /**
+     * Get time until exhaustion (returns -1 if infinite)
+     */
+    getTimeUntilExhaustion(channelCapacity: string): number;
+    /**
+     * Check if stream is near exhaustion
+     */
+    isNearExhaustion(channelCapacity: string): boolean;
+    /**
+     * Create manual checkpoint
+     */
+    createCheckpoint(): {
+        id: string;
+        amount: string;
+        timestamp: number;
+    };
+    /**
+     * Subscribe to stream events
+     */
+    onEvent(callback: (event: StreamEvent) => void): () => void;
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+    private startUpdateTimer;
+    private startCheckpointTimer;
+    private stopTimers;
+    private updateTotals;
+    private calculateAmount;
+    private getEffectiveRate;
+    private addMeteringRecord;
+    private emitEvent;
+    private generateSessionId;
+}
+/**
+ * Create a simple fixed-rate flow controller
+ */
+declare function createFixedRateFlow(channelId: string, ratePerSecond: string, config?: FlowConfig): FlowController;
+/**
+ * Create a tiered rate flow controller
+ */
+declare function createTieredRateFlow(channelId: string, baseRate: string, tiers: Array<{
+    threshold: string;
+    rate: string;
+}>, config?: FlowConfig): FlowController;
+
+/**
+ * Rate controller configuration
+ */
+interface RateControllerConfig {
+    maxChangePercent?: number;
+    minChangeInterval?: number;
+    smoothingFactor?: number;
+}
+/**
+ * Rate history entry
+ */
+interface RateHistoryEntry {
+    timestamp: number;
+    rate: string;
+    reason: string;
+    previousRate: string;
+}
+/**
+ * Rate controller for managing and adjusting streaming rates
+ */
+declare class RateController {
+    private currentRate;
+    private config;
+    private history;
+    private lastChangeTime;
+    constructor(initialRate: StreamRate, config?: RateControllerConfig);
+    /**
+     * Get current rate configuration
+     */
+    getRate(): StreamRate;
+    /**
+     * Get current effective rate
+     */
+    getEffectiveRate(totalUsage?: string): string;
+    /**
+     * Request rate adjustment
+     */
+    adjustRate(request: RateAdjustmentRequest): {
+        success: boolean;
+        error?: string;
+        newRate?: string;
+        adjustedAmount?: string;
+    };
+    /**
+     * Set rate bounds
+     */
+    setBounds(minRate?: string, maxRate?: string): void;
+    /**
+     * Add or update a tier
+     */
+    addTier(threshold: string, rate: string): void;
+    /**
+     * Remove a tier
+     */
+    removeTier(threshold: string): boolean;
+    /**
+     * Get rate history
+     */
+    getHistory(): RateHistoryEntry[];
+    /**
+     * Calculate average rate over time period
+     */
+    getAverageRate(startTime: number, endTime: number): string;
+    /**
+     * Calculate rate for dynamic pricing based on demand
+     */
+    calculateDynamicRate(demand: number, // 0-1 representing demand level
+    _baseRate?: string): string;
+    /**
+     * Apply exponential smoothing for rate changes
+     */
+    smoothRate(targetRate: string): string;
+    private calculateTieredRate;
+    private calculateChangePercent;
+    private applyMaxChange;
+}
+/**
+ * Rate limiter for preventing abuse
+ */
+declare class RateLimiter {
+    private requests;
+    private maxRequests;
+    private windowMs;
+    constructor(maxRequests?: number, windowMs?: number);
+    /**
+     * Check if request is allowed
+     */
+    isAllowed(key: string): boolean;
+    /**
+     * Get remaining requests in window
+     */
+    getRemainingRequests(key: string): number;
+    /**
+     * Reset limits for a key
+     */
+    reset(key: string): void;
+    /**
+     * Clear all limits
+     */
+    clear(): void;
+}
+/**
+ * Calculate optimal rate based on channel parameters
+ */
+declare function calculateOptimalRate(channelCapacity: string, desiredDurationSeconds: number, bufferPercent?: number): string;
+/**
+ * Convert rate between time units
+ */
+declare function convertRate(rate: string, fromUnit: 'second' | 'minute' | 'hour' | 'day', toUnit: 'second' | 'minute' | 'hour' | 'day'): string;
+
+/**
+ * Metering configuration
+ */
+interface MeteringConfig {
+    recordInterval?: number;
+    aggregationInterval?: number;
+    maxRecords?: number;
+    precision?: number;
+}
+/**
+ * Aggregated usage data
+ */
+interface AggregatedUsage {
+    period: string;
+    totalAmount: string;
+    totalDuration: number;
+    averageRate: string;
+    recordCount: number;
+}
+/**
+ * Metering manager for tracking usage
+ */
+declare class MeteringManager {
+    private records;
+    private config;
+    private sessionId;
+    private startTime;
+    constructor(sessionId: string, config?: MeteringConfig);
+    /**
+     * Record usage
+     */
+    record(duration: number, amount: string, rate: string, metadata?: Record<string, unknown>): MeteringRecord;
+    /**
+     * Get all records
+     */
+    getRecords(): MeteringRecord[];
+    /**
+     * Get records in time range
+     */
+    getRecordsInRange(startTime: number, endTime: number): MeteringRecord[];
+    /**
+     * Calculate usage metrics
+     */
+    getMetrics(): UsageMetrics;
+    /**
+     * Get aggregated usage by period
+     */
+    aggregate(intervalSeconds?: number): AggregatedUsage[];
+    /**
+     * Get cumulative amount at a point in time
+     */
+    getCumulativeAt(timestamp: number): string;
+    /**
+     * Calculate usage for billing period
+     */
+    getUsageForBillingPeriod(startTime: number, endTime: number): {
+        amount: string;
+        duration: number;
+        records: number;
+    };
+    /**
+     * Export records for backup/audit
+     */
+    export(): string;
+    /**
+     * Import records from backup
+     */
+    import(data: string): {
+        success: boolean;
+        recordsImported: number;
+    };
+    /**
+     * Clear all records
+     */
+    clear(): void;
+    private calculateCumulative;
+    private pruneRecords;
+    private getHourlyBreakdown;
+}
+/**
+ * Calculate pro-rated usage for partial periods
+ */
+declare function calculateProRatedUsage(fullPeriodAmount: string, fullPeriodSeconds: number, actualSeconds: number): string;
+/**
+ * Estimate usage based on historical data
+ */
+declare function estimateUsage(metrics: UsageMetrics, futureSeconds: number): string;
+/**
+ * Compare usage across periods
+ */
+declare function compareUsage(current: UsageMetrics, previous: UsageMetrics): {
+    amountChange: string;
+    amountChangePercent: number;
+    rateChange: string;
+    rateChangePercent: number;
+};
+
+/**
+ * Billing manager configuration
+ */
+interface BillingManagerConfig {
+    autoInvoice?: boolean;
+    invoiceInterval?: number;
+    currency?: string;
+    taxRate?: number;
+}
+/**
+ * Billing manager for generating invoices from metering data
+ */
+declare class BillingManager {
+    private config;
+    private billingConfig;
+    private invoices;
+    private channelId;
+    private payer;
+    private payee;
+    private lastInvoiceTime;
+    constructor(channelId: string, payer: string, payee: string, billingConfig: BillingConfig, config?: BillingManagerConfig);
+    /**
+     * Generate invoice from metering records
+     */
+    generateInvoice(records: MeteringRecord[], startTime: number, endTime: number): Invoice;
+    /**
+     * Get all invoices
+     */
+    getInvoices(): Invoice[];
+    /**
+     * Get invoice by ID
+     */
+    getInvoice(id: string): Invoice | undefined;
+    /**
+     * Mark invoice as paid
+     */
+    markPaid(invoiceId: string): boolean;
+    /**
+     * Mark invoice as settled
+     */
+    markSettled(invoiceId: string): boolean;
+    /**
+     * Get pending amount
+     */
+    getPendingAmount(): string;
+    /**
+     * Get total billed amount
+     */
+    getTotalBilled(): string;
+    /**
+     * Check if new invoice is due
+     */
+    isInvoiceDue(currentTime: number): boolean;
+    /**
+     * Calculate amount for billing period
+     */
+    calculatePeriodAmount(rate: string, durationSeconds: number): string;
+    /**
+     * Apply minimum charge
+     */
+    applyMinimumCharge(amount: string): string;
+    /**
+     * Calculate grace period savings
+     */
+    calculateGracePeriodSavings(rate: string, totalDuration: number): string;
+    /**
+     * Get billing summary
+     */
+    getSummary(): {
+        totalInvoices: number;
+        totalBilled: string;
+        totalPaid: string;
+        totalPending: string;
+        averageInvoice: string;
+    };
+    /**
+     * Export billing data
+     */
+    export(): string;
+    private createInvoiceItems;
+    private calculateSubtotal;
+    private calculateFees;
+    private applyRounding;
+    private getPeriodSeconds;
+    private getPeriodName;
+    private calculateQuantity;
+    private generateInvoiceId;
+}
+/**
+ * Format currency amount for display
+ */
+declare function formatCurrencyAmount(amount: string, decimals?: number, symbol?: string): string;
+/**
+ * Parse currency amount from display format
+ */
+declare function parseCurrencyAmount(display: string, decimals?: number): string;
+/**
+ * Calculate estimated bill for future period
+ */
+declare function estimateFutureBill(currentRate: string, durationSeconds: number, minimumCharge?: string): string;
+
+export { type AggregatedUsage, BillingConfig, BillingManager, type BillingManagerConfig, BillingPeriod, type FlowConfig, FlowController, Invoice, InvoiceItem, type MeteringConfig, MeteringManager, MeteringRecord, RateAdjustmentRequest, RateController, type RateControllerConfig, type RateHistoryEntry, RateLimiter, RateType, StreamEvent, StreamRate, StreamSession, StreamState, UsageMetrics, calculateOptimalRate, calculateProRatedUsage, compareUsage, convertRate, createFixedRateFlow, createTieredRateFlow, estimateFutureBill, estimateUsage, formatCurrencyAmount, parseCurrencyAmount };