@t402/streaming-payments 1.0.0-beta.1

package/dist/channels/index.d.ts

@@ -0,0 +1,1560 @@
+import { z } from 'zod';
+
+/**
+ * Chain identifier (CAIP-2)
+ */
+type ChainId = string;
+/**
+ * Asset identifier (contract address or native)
+ */
+type AssetId = string;
+/**
+ * Channel state
+ */
+declare const ChannelState: z.ZodEnum<["created", "funding", "open", "paused", "closing", "disputing", "closed", "expired"]>;
+type ChannelState = z.infer<typeof ChannelState>;
+/**
+ * Channel configuration
+ */
+declare const ChannelConfig: z.ZodObject<{
+    minDeposit: z.ZodDefault<z.ZodString>;
+    maxDeposit: z.ZodOptional<z.ZodString>;
+    challengePeriod: z.ZodDefault<z.ZodNumber>;
+    expirationTime: z.ZodOptional<z.ZodNumber>;
+    checkpointInterval: z.ZodDefault<z.ZodNumber>;
+    minCheckpointAmount: z.ZodDefault<z.ZodString>;
+    channelFee: z.ZodDefault<z.ZodString>;
+    settlementFee: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    minDeposit: string;
+    challengePeriod: number;
+    checkpointInterval: number;
+    minCheckpointAmount: string;
+    channelFee: string;
+    settlementFee: string;
+    maxDeposit?: string | undefined;
+    expirationTime?: number | undefined;
+}, {
+    minDeposit?: string | undefined;
+    maxDeposit?: string | undefined;
+    challengePeriod?: number | undefined;
+    expirationTime?: number | undefined;
+    checkpointInterval?: number | undefined;
+    minCheckpointAmount?: string | undefined;
+    channelFee?: string | undefined;
+    settlementFee?: string | undefined;
+}>;
+type ChannelConfig = z.infer<typeof ChannelConfig>;
+/**
+ * Channel participant
+ */
+declare const ChannelParticipant: z.ZodObject<{
+    address: z.ZodString;
+    role: z.ZodEnum<["payer", "payee"]>;
+    publicKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+    role: "payer" | "payee";
+    publicKey?: string | undefined;
+}, {
+    address: string;
+    role: "payer" | "payee";
+    publicKey?: string | undefined;
+}>;
+type ChannelParticipant = z.infer<typeof ChannelParticipant>;
+/**
+ * Channel balance
+ */
+declare const ChannelBalance: z.ZodObject<{
+    payer: z.ZodString;
+    payee: z.ZodString;
+    total: z.ZodString;
+    locked: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    payer: string;
+    payee: string;
+    total: string;
+    locked: string;
+}, {
+    payer: string;
+    payee: string;
+    total: string;
+    locked?: string | undefined;
+}>;
+type ChannelBalance = z.infer<typeof ChannelBalance>;
+/**
+ * Payment channel checkpoint
+ */
+declare const ChannelCheckpoint: z.ZodObject<{
+    channelId: z.ZodString;
+    sequence: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    balance: z.ZodObject<{
+        payer: z.ZodString;
+        payee: z.ZodString;
+        total: z.ZodString;
+        locked: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        payer: string;
+        payee: string;
+        total: string;
+        locked: string;
+    }, {
+        payer: string;
+        payee: string;
+        total: string;
+        locked?: string | undefined;
+    }>;
+    amountStreamed: z.ZodString;
+    payerSignature: z.ZodString;
+    payeeSignature: z.ZodOptional<z.ZodString>;
+    stateRoot: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    channelId: string;
+    sequence: number;
+    timestamp: number;
+    balance: {
+        payer: string;
+        payee: string;
+        total: string;
+        locked: string;
+    };
+    amountStreamed: string;
+    payerSignature: string;
+    payeeSignature?: string | undefined;
+    stateRoot?: string | undefined;
+}, {
+    channelId: string;
+    sequence: number;
+    timestamp: number;
+    balance: {
+        payer: string;
+        payee: string;
+        total: string;
+        locked?: string | undefined;
+    };
+    amountStreamed: string;
+    payerSignature: string;
+    payeeSignature?: string | undefined;
+    stateRoot?: string | undefined;
+}>;
+type ChannelCheckpoint = z.infer<typeof ChannelCheckpoint>;
+/**
+ * Streaming payment channel
+ */
+declare const StreamingChannel: z.ZodObject<{
+    id: z.ZodString;
+    state: z.ZodEnum<["created", "funding", "open", "paused", "closing", "disputing", "closed", "expired"]>;
+    chain: z.ZodString;
+    asset: z.ZodString;
+    payer: z.ZodObject<{
+        address: z.ZodString;
+        role: z.ZodEnum<["payer", "payee"]>;
+        publicKey: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        role: "payer" | "payee";
+        publicKey?: string | undefined;
+    }, {
+        address: string;
+        role: "payer" | "payee";
+        publicKey?: string | undefined;
+    }>;
+    payee: z.ZodObject<{
+        address: z.ZodString;
+        role: z.ZodEnum<["payer", "payee"]>;
+        publicKey: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        role: "payer" | "payee";
+        publicKey?: string | undefined;
+    }, {
+        address: string;
+        role: "payer" | "payee";
+        publicKey?: string | undefined;
+    }>;
+    balance: z.ZodObject<{
+        payer: z.ZodString;
+        payee: z.ZodString;
+        total: z.ZodString;
+        locked: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        payer: string;
+        payee: string;
+        total: string;
+        locked: string;
+    }, {
+        payer: string;
+        payee: string;
+        total: string;
+        locked?: string | undefined;
+    }>;
+    ratePerSecond: z.ZodString;
+    startTime: z.ZodOptional<z.ZodNumber>;
+    pausedAt: z.ZodOptional<z.ZodNumber>;
+    config: z.ZodObject<{
+        minDeposit: z.ZodDefault<z.ZodString>;
+        maxDeposit: z.ZodOptional<z.ZodString>;
+        challengePeriod: z.ZodDefault<z.ZodNumber>;
+        expirationTime: z.ZodOptional<z.ZodNumber>;
+        checkpointInterval: z.ZodDefault<z.ZodNumber>;
+        minCheckpointAmount: z.ZodDefault<z.ZodString>;
+        channelFee: z.ZodDefault<z.ZodString>;
+        settlementFee: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        minDeposit: string;
+        challengePeriod: number;
+        checkpointInterval: number;
+        minCheckpointAmount: string;
+        channelFee: string;
+        settlementFee: string;
+        maxDeposit?: string | undefined;
+        expirationTime?: number | undefined;
+    }, {
+        minDeposit?: string | undefined;
+        maxDeposit?: string | undefined;
+        challengePeriod?: number | undefined;
+        expirationTime?: number | undefined;
+        checkpointInterval?: number | undefined;
+        minCheckpointAmount?: string | undefined;
+        channelFee?: string | undefined;
+        settlementFee?: string | undefined;
+    }>;
+    contractAddress: z.ZodOptional<z.ZodString>;
+    fundingTxHash: z.ZodOptional<z.ZodString>;
+    closingTxHash: z.ZodOptional<z.ZodString>;
+    checkpoints: z.ZodArray<z.ZodObject<{
+        channelId: z.ZodString;
+        sequence: z.ZodNumber;
+        timestamp: z.ZodNumber;
+        balance: z.ZodObject<{
+            payer: z.ZodString;
+            payee: z.ZodString;
+            total: z.ZodString;
+            locked: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        }, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        }>;
+        amountStreamed: z.ZodString;
+        payerSignature: z.ZodString;
+        payeeSignature: z.ZodOptional<z.ZodString>;
+        stateRoot: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }, {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }>, "many">;
+    latestCheckpoint: z.ZodOptional<z.ZodObject<{
+        channelId: z.ZodString;
+        sequence: z.ZodNumber;
+        timestamp: z.ZodNumber;
+        balance: z.ZodObject<{
+            payer: z.ZodString;
+            payee: z.ZodString;
+            total: z.ZodString;
+            locked: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        }, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        }>;
+        amountStreamed: z.ZodString;
+        payerSignature: z.ZodString;
+        payeeSignature: z.ZodOptional<z.ZodString>;
+        stateRoot: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }, {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }>>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    closedAt: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    payer: {
+        address: string;
+        role: "payer" | "payee";
+        publicKey?: string | undefined;
+    };
+    payee: {
+        address: string;
+        role: "payer" | "payee";
+        publicKey?: string | undefined;
+    };
+    balance: {
+        payer: string;
+        payee: string;
+        total: string;
+        locked: string;
+    };
+    id: string;
+    state: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+    chain: string;
+    asset: string;
+    ratePerSecond: string;
+    config: {
+        minDeposit: string;
+        challengePeriod: number;
+        checkpointInterval: number;
+        minCheckpointAmount: string;
+        channelFee: string;
+        settlementFee: string;
+        maxDeposit?: string | undefined;
+        expirationTime?: number | undefined;
+    };
+    checkpoints: {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }[];
+    createdAt: number;
+    updatedAt: number;
+    startTime?: number | undefined;
+    pausedAt?: number | undefined;
+    contractAddress?: string | undefined;
+    fundingTxHash?: string | undefined;
+    closingTxHash?: string | undefined;
+    latestCheckpoint?: {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    } | undefined;
+    closedAt?: number | undefined;
+}, {
+    payer: {
+        address: string;
+        role: "payer" | "payee";
+        publicKey?: string | undefined;
+    };
+    payee: {
+        address: string;
+        role: "payer" | "payee";
+        publicKey?: string | undefined;
+    };
+    balance: {
+        payer: string;
+        payee: string;
+        total: string;
+        locked?: string | undefined;
+    };
+    id: string;
+    state: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+    chain: string;
+    asset: string;
+    ratePerSecond: string;
+    config: {
+        minDeposit?: string | undefined;
+        maxDeposit?: string | undefined;
+        challengePeriod?: number | undefined;
+        expirationTime?: number | undefined;
+        checkpointInterval?: number | undefined;
+        minCheckpointAmount?: string | undefined;
+        channelFee?: string | undefined;
+        settlementFee?: string | undefined;
+    };
+    checkpoints: {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }[];
+    createdAt: number;
+    updatedAt: number;
+    startTime?: number | undefined;
+    pausedAt?: number | undefined;
+    contractAddress?: string | undefined;
+    fundingTxHash?: string | undefined;
+    closingTxHash?: string | undefined;
+    latestCheckpoint?: {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    } | undefined;
+    closedAt?: number | undefined;
+}>;
+type StreamingChannel = z.infer<typeof StreamingChannel>;
+/**
+ * Channel creation request
+ */
+declare const ChannelCreateRequest: z.ZodObject<{
+    chain: z.ZodString;
+    asset: z.ZodString;
+    payerAddress: z.ZodString;
+    payeeAddress: z.ZodString;
+    depositAmount: z.ZodString;
+    ratePerSecond: z.ZodString;
+    config: z.ZodOptional<z.ZodObject<{
+        minDeposit: z.ZodDefault<z.ZodString>;
+        maxDeposit: z.ZodOptional<z.ZodString>;
+        challengePeriod: z.ZodDefault<z.ZodNumber>;
+        expirationTime: z.ZodOptional<z.ZodNumber>;
+        checkpointInterval: z.ZodDefault<z.ZodNumber>;
+        minCheckpointAmount: z.ZodDefault<z.ZodString>;
+        channelFee: z.ZodDefault<z.ZodString>;
+        settlementFee: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        minDeposit: string;
+        challengePeriod: number;
+        checkpointInterval: number;
+        minCheckpointAmount: string;
+        channelFee: string;
+        settlementFee: string;
+        maxDeposit?: string | undefined;
+        expirationTime?: number | undefined;
+    }, {
+        minDeposit?: string | undefined;
+        maxDeposit?: string | undefined;
+        challengePeriod?: number | undefined;
+        expirationTime?: number | undefined;
+        checkpointInterval?: number | undefined;
+        minCheckpointAmount?: string | undefined;
+        channelFee?: string | undefined;
+        settlementFee?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    chain: string;
+    asset: string;
+    ratePerSecond: string;
+    payerAddress: string;
+    payeeAddress: string;
+    depositAmount: string;
+    config?: {
+        minDeposit: string;
+        challengePeriod: number;
+        checkpointInterval: number;
+        minCheckpointAmount: string;
+        channelFee: string;
+        settlementFee: string;
+        maxDeposit?: string | undefined;
+        expirationTime?: number | undefined;
+    } | undefined;
+}, {
+    chain: string;
+    asset: string;
+    ratePerSecond: string;
+    payerAddress: string;
+    payeeAddress: string;
+    depositAmount: string;
+    config?: {
+        minDeposit?: string | undefined;
+        maxDeposit?: string | undefined;
+        challengePeriod?: number | undefined;
+        expirationTime?: number | undefined;
+        checkpointInterval?: number | undefined;
+        minCheckpointAmount?: string | undefined;
+        channelFee?: string | undefined;
+        settlementFee?: string | undefined;
+    } | undefined;
+}>;
+type ChannelCreateRequest = z.infer<typeof ChannelCreateRequest>;
+/**
+ * Channel funding transaction
+ */
+declare const FundingTransaction: z.ZodObject<{
+    channelId: z.ZodString;
+    txHash: z.ZodString;
+    amount: z.ZodString;
+    sender: z.ZodString;
+    blockNumber: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodNumber;
+    confirmed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    channelId: string;
+    timestamp: number;
+    txHash: string;
+    amount: string;
+    sender: string;
+    confirmed: boolean;
+    blockNumber?: number | undefined;
+}, {
+    channelId: string;
+    timestamp: number;
+    txHash: string;
+    amount: string;
+    sender: string;
+    confirmed: boolean;
+    blockNumber?: number | undefined;
+}>;
+type FundingTransaction = z.infer<typeof FundingTransaction>;
+/**
+ * Channel close request
+ */
+declare const ChannelCloseRequest: z.ZodObject<{
+    channelId: z.ZodString;
+    initiator: z.ZodString;
+    reason: z.ZodEnum<["mutual", "unilateral", "timeout", "dispute"]>;
+    finalCheckpoint: z.ZodOptional<z.ZodObject<{
+        channelId: z.ZodString;
+        sequence: z.ZodNumber;
+        timestamp: z.ZodNumber;
+        balance: z.ZodObject<{
+            payer: z.ZodString;
+            payee: z.ZodString;
+            total: z.ZodString;
+            locked: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        }, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        }>;
+        amountStreamed: z.ZodString;
+        payerSignature: z.ZodString;
+        payeeSignature: z.ZodOptional<z.ZodString>;
+        stateRoot: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }, {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }>>;
+    signature: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    channelId: string;
+    initiator: string;
+    reason: "mutual" | "unilateral" | "timeout" | "dispute";
+    signature: string;
+    finalCheckpoint?: {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    } | undefined;
+}, {
+    channelId: string;
+    initiator: string;
+    reason: "mutual" | "unilateral" | "timeout" | "dispute";
+    signature: string;
+    finalCheckpoint?: {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    } | undefined;
+}>;
+type ChannelCloseRequest = z.infer<typeof ChannelCloseRequest>;
+/**
+ * Channel dispute
+ */
+declare const ChannelDispute: z.ZodObject<{
+    channelId: z.ZodString;
+    disputeId: z.ZodString;
+    initiator: z.ZodString;
+    reason: z.ZodString;
+    claimedBalance: z.ZodObject<{
+        payer: z.ZodString;
+        payee: z.ZodString;
+        total: z.ZodString;
+        locked: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        payer: string;
+        payee: string;
+        total: string;
+        locked: string;
+    }, {
+        payer: string;
+        payee: string;
+        total: string;
+        locked?: string | undefined;
+    }>;
+    evidence: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["checkpoint", "signature", "transaction"]>;
+        data: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "signature" | "checkpoint" | "transaction";
+        timestamp: number;
+        data: string;
+    }, {
+        type: "signature" | "checkpoint" | "transaction";
+        timestamp: number;
+        data: string;
+    }>, "many">;
+    status: z.ZodEnum<["pending", "resolved", "rejected"]>;
+    resolution: z.ZodOptional<z.ZodObject<{
+        winner: z.ZodOptional<z.ZodString>;
+        finalBalance: z.ZodOptional<z.ZodObject<{
+            payer: z.ZodString;
+            payee: z.ZodString;
+            total: z.ZodString;
+            locked: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        }, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        }>>;
+        timestamp: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp?: number | undefined;
+        winner?: string | undefined;
+        finalBalance?: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        } | undefined;
+    }, {
+        timestamp?: number | undefined;
+        winner?: string | undefined;
+        finalBalance?: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        } | undefined;
+    }>>;
+    createdAt: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "resolved" | "rejected";
+    channelId: string;
+    createdAt: number;
+    initiator: string;
+    reason: string;
+    disputeId: string;
+    claimedBalance: {
+        payer: string;
+        payee: string;
+        total: string;
+        locked: string;
+    };
+    evidence: {
+        type: "signature" | "checkpoint" | "transaction";
+        timestamp: number;
+        data: string;
+    }[];
+    expiresAt: number;
+    resolution?: {
+        timestamp?: number | undefined;
+        winner?: string | undefined;
+        finalBalance?: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        } | undefined;
+    } | undefined;
+}, {
+    status: "pending" | "resolved" | "rejected";
+    channelId: string;
+    createdAt: number;
+    initiator: string;
+    reason: string;
+    disputeId: string;
+    claimedBalance: {
+        payer: string;
+        payee: string;
+        total: string;
+        locked?: string | undefined;
+    };
+    evidence: {
+        type: "signature" | "checkpoint" | "transaction";
+        timestamp: number;
+        data: string;
+    }[];
+    expiresAt: number;
+    resolution?: {
+        timestamp?: number | undefined;
+        winner?: string | undefined;
+        finalBalance?: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+type ChannelDispute = z.infer<typeof ChannelDispute>;
+/**
+ * Channel state transition
+ */
+declare const StateTransition: z.ZodObject<{
+    from: z.ZodEnum<["created", "funding", "open", "paused", "closing", "disputing", "closed", "expired"]>;
+    to: z.ZodEnum<["created", "funding", "open", "paused", "closing", "disputing", "closed", "expired"]>;
+    trigger: z.ZodString;
+    timestamp: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    from: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+    to: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+    trigger: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    timestamp: number;
+    from: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+    to: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+    trigger: string;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+type StateTransition = z.infer<typeof StateTransition>;
+/**
+ * Recovery data for channel state restoration
+ */
+declare const RecoveryData: z.ZodObject<{
+    channelId: z.ZodString;
+    checkpoints: z.ZodArray<z.ZodObject<{
+        channelId: z.ZodString;
+        sequence: z.ZodNumber;
+        timestamp: z.ZodNumber;
+        balance: z.ZodObject<{
+            payer: z.ZodString;
+            payee: z.ZodString;
+            total: z.ZodString;
+            locked: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        }, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        }>;
+        amountStreamed: z.ZodString;
+        payerSignature: z.ZodString;
+        payeeSignature: z.ZodOptional<z.ZodString>;
+        stateRoot: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }, {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }>, "many">;
+    transactions: z.ZodArray<z.ZodObject<{
+        channelId: z.ZodString;
+        txHash: z.ZodString;
+        amount: z.ZodString;
+        sender: z.ZodString;
+        blockNumber: z.ZodOptional<z.ZodNumber>;
+        timestamp: z.ZodNumber;
+        confirmed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        channelId: string;
+        timestamp: number;
+        txHash: string;
+        amount: string;
+        sender: string;
+        confirmed: boolean;
+        blockNumber?: number | undefined;
+    }, {
+        channelId: string;
+        timestamp: number;
+        txHash: string;
+        amount: string;
+        sender: string;
+        confirmed: boolean;
+        blockNumber?: number | undefined;
+    }>, "many">;
+    disputes: z.ZodArray<z.ZodObject<{
+        channelId: z.ZodString;
+        disputeId: z.ZodString;
+        initiator: z.ZodString;
+        reason: z.ZodString;
+        claimedBalance: z.ZodObject<{
+            payer: z.ZodString;
+            payee: z.ZodString;
+            total: z.ZodString;
+            locked: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        }, {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        }>;
+        evidence: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["checkpoint", "signature", "transaction"]>;
+            data: z.ZodString;
+            timestamp: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            type: "signature" | "checkpoint" | "transaction";
+            timestamp: number;
+            data: string;
+        }, {
+            type: "signature" | "checkpoint" | "transaction";
+            timestamp: number;
+            data: string;
+        }>, "many">;
+        status: z.ZodEnum<["pending", "resolved", "rejected"]>;
+        resolution: z.ZodOptional<z.ZodObject<{
+            winner: z.ZodOptional<z.ZodString>;
+            finalBalance: z.ZodOptional<z.ZodObject<{
+                payer: z.ZodString;
+                payee: z.ZodString;
+                total: z.ZodString;
+                locked: z.ZodDefault<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                payer: string;
+                payee: string;
+                total: string;
+                locked: string;
+            }, {
+                payer: string;
+                payee: string;
+                total: string;
+                locked?: string | undefined;
+            }>>;
+            timestamp: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp?: number | undefined;
+            winner?: string | undefined;
+            finalBalance?: {
+                payer: string;
+                payee: string;
+                total: string;
+                locked: string;
+            } | undefined;
+        }, {
+            timestamp?: number | undefined;
+            winner?: string | undefined;
+            finalBalance?: {
+                payer: string;
+                payee: string;
+                total: string;
+                locked?: string | undefined;
+            } | undefined;
+        }>>;
+        createdAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        status: "pending" | "resolved" | "rejected";
+        channelId: string;
+        createdAt: number;
+        initiator: string;
+        reason: string;
+        disputeId: string;
+        claimedBalance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        };
+        evidence: {
+            type: "signature" | "checkpoint" | "transaction";
+            timestamp: number;
+            data: string;
+        }[];
+        expiresAt: number;
+        resolution?: {
+            timestamp?: number | undefined;
+            winner?: string | undefined;
+            finalBalance?: {
+                payer: string;
+                payee: string;
+                total: string;
+                locked: string;
+            } | undefined;
+        } | undefined;
+    }, {
+        status: "pending" | "resolved" | "rejected";
+        channelId: string;
+        createdAt: number;
+        initiator: string;
+        reason: string;
+        disputeId: string;
+        claimedBalance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        };
+        evidence: {
+            type: "signature" | "checkpoint" | "transaction";
+            timestamp: number;
+            data: string;
+        }[];
+        expiresAt: number;
+        resolution?: {
+            timestamp?: number | undefined;
+            winner?: string | undefined;
+            finalBalance?: {
+                payer: string;
+                payee: string;
+                total: string;
+                locked?: string | undefined;
+            } | undefined;
+        } | undefined;
+    }>, "many">;
+    stateHistory: z.ZodArray<z.ZodObject<{
+        from: z.ZodEnum<["created", "funding", "open", "paused", "closing", "disputing", "closed", "expired"]>;
+        to: z.ZodEnum<["created", "funding", "open", "paused", "closing", "disputing", "closed", "expired"]>;
+        trigger: z.ZodString;
+        timestamp: z.ZodNumber;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: number;
+        from: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+        to: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+        trigger: string;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        timestamp: number;
+        from: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+        to: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+        trigger: string;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">;
+    recoveredAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    channelId: string;
+    checkpoints: {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }[];
+    transactions: {
+        channelId: string;
+        timestamp: number;
+        txHash: string;
+        amount: string;
+        sender: string;
+        confirmed: boolean;
+        blockNumber?: number | undefined;
+    }[];
+    disputes: {
+        status: "pending" | "resolved" | "rejected";
+        channelId: string;
+        createdAt: number;
+        initiator: string;
+        reason: string;
+        disputeId: string;
+        claimedBalance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked: string;
+        };
+        evidence: {
+            type: "signature" | "checkpoint" | "transaction";
+            timestamp: number;
+            data: string;
+        }[];
+        expiresAt: number;
+        resolution?: {
+            timestamp?: number | undefined;
+            winner?: string | undefined;
+            finalBalance?: {
+                payer: string;
+                payee: string;
+                total: string;
+                locked: string;
+            } | undefined;
+        } | undefined;
+    }[];
+    stateHistory: {
+        timestamp: number;
+        from: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+        to: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+        trigger: string;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recoveredAt: number;
+}, {
+    channelId: string;
+    checkpoints: {
+        channelId: string;
+        sequence: number;
+        timestamp: number;
+        balance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        };
+        amountStreamed: string;
+        payerSignature: string;
+        payeeSignature?: string | undefined;
+        stateRoot?: string | undefined;
+    }[];
+    transactions: {
+        channelId: string;
+        timestamp: number;
+        txHash: string;
+        amount: string;
+        sender: string;
+        confirmed: boolean;
+        blockNumber?: number | undefined;
+    }[];
+    disputes: {
+        status: "pending" | "resolved" | "rejected";
+        channelId: string;
+        createdAt: number;
+        initiator: string;
+        reason: string;
+        disputeId: string;
+        claimedBalance: {
+            payer: string;
+            payee: string;
+            total: string;
+            locked?: string | undefined;
+        };
+        evidence: {
+            type: "signature" | "checkpoint" | "transaction";
+            timestamp: number;
+            data: string;
+        }[];
+        expiresAt: number;
+        resolution?: {
+            timestamp?: number | undefined;
+            winner?: string | undefined;
+            finalBalance?: {
+                payer: string;
+                payee: string;
+                total: string;
+                locked?: string | undefined;
+            } | undefined;
+        } | undefined;
+    }[];
+    stateHistory: {
+        timestamp: number;
+        from: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+        to: "created" | "funding" | "open" | "paused" | "closing" | "disputing" | "closed" | "expired";
+        trigger: string;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recoveredAt: number;
+}>;
+type RecoveryData = z.infer<typeof RecoveryData>;
+
+/**
+ * State machine event
+ */
+type StateEvent = {
+    type: 'FUND';
+    txHash: string;
+    amount: string;
+} | {
+    type: 'CONFIRM_FUNDING';
+} | {
+    type: 'START_STREAMING';
+} | {
+    type: 'PAUSE';
+} | {
+    type: 'RESUME';
+} | {
+    type: 'INITIATE_CLOSE';
+    initiator: string;
+} | {
+    type: 'MUTUAL_CLOSE';
+    signature: string;
+} | {
+    type: 'DISPUTE';
+    reason: string;
+} | {
+    type: 'RESOLVE_DISPUTE';
+    winner: string;
+} | {
+    type: 'FINALIZE';
+} | {
+    type: 'TIMEOUT';
+};
+/**
+ * Channel state machine
+ */
+declare class ChannelStateMachine {
+    private channel;
+    private transitions;
+    private listeners;
+    constructor(channel: StreamingChannel);
+    /**
+     * Get current channel state
+     */
+    getChannel(): StreamingChannel;
+    /**
+     * Get current state
+     */
+    getState(): ChannelState;
+    /**
+     * Get state history
+     */
+    getTransitions(): StateTransition[];
+    /**
+     * Check if a transition is valid
+     */
+    canTransition(to: ChannelState): boolean;
+    /**
+     * Get allowed transitions from current state
+     */
+    getAllowedTransitions(): ChannelState[];
+    /**
+     * Process a state event
+     */
+    process(event: StateEvent): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Update channel balance
+     */
+    updateBalance(payerBalance: string, payeeBalance: string): void;
+    /**
+     * Add checkpoint
+     */
+    addCheckpoint(checkpoint: ChannelCheckpoint): void;
+    /**
+     * Get current streamed amount
+     */
+    getCurrentStreamedAmount(): string;
+    /**
+     * Calculate remaining balance
+     */
+    getRemainingBalance(): string;
+    /**
+     * Check if channel needs checkpoint
+     */
+    needsCheckpoint(): boolean;
+    /**
+     * Subscribe to state changes
+     */
+    onStateChange(state: ChannelState | '*', callback: (channel: StreamingChannel) => void): () => void;
+    private notifyListeners;
+}
+/**
+ * Check if channel is active (can stream)
+ */
+declare function isChannelActive(channel: StreamingChannel): boolean;
+/**
+ * Check if channel is terminal (cannot transition further)
+ */
+declare function isChannelTerminal(channel: StreamingChannel): boolean;
+/**
+ * Calculate channel utilization
+ */
+declare function getChannelUtilization(channel: StreamingChannel): number;
+
+/**
+ * Channel opening configuration
+ */
+interface ChannelOpeningConfig {
+    fundingTimeout?: number;
+    confirmations?: number;
+    contractAddress?: string;
+}
+/**
+ * Channel opening result
+ */
+interface ChannelOpeningResult {
+    channel: StreamingChannel;
+    stateMachine: ChannelStateMachine;
+    fundingRequired: {
+        amount: string;
+        to: string;
+        data?: string;
+    };
+}
+/**
+ * Channel opener - handles channel creation and funding
+ */
+declare class ChannelOpener {
+    private config;
+    constructor(config?: ChannelOpeningConfig);
+    /**
+     * Create a new channel
+     */
+    create(request: ChannelCreateRequest): ChannelOpeningResult;
+    /**
+     * Process funding transaction
+     */
+    processFunding(stateMachine: ChannelStateMachine, txHash: string, amount: string): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Confirm funding (after required confirmations)
+     */
+    confirmFunding(stateMachine: ChannelStateMachine, _confirmation: FundingTransaction): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Handle funding timeout
+     */
+    handleTimeout(stateMachine: ChannelStateMachine): {
+        success: boolean;
+        expired: boolean;
+    };
+    /**
+     * Validate channel create request
+     */
+    private validateCreateRequest;
+    /**
+     * Generate unique channel ID
+     */
+    private generateChannelId;
+    /**
+     * Calculate funding requirements for channel
+     */
+    private calculateFundingRequirements;
+    /**
+     * Encode funding transaction data
+     */
+    private encodeFundingData;
+}
+/**
+ * Estimate channel duration based on rate
+ */
+declare function estimateChannelDuration(depositAmount: string, ratePerSecond: string): {
+    seconds: number;
+    formatted: string;
+};
+/**
+ * Calculate required deposit for desired duration
+ */
+declare function calculateRequiredDeposit(ratePerSecond: string, durationSeconds: number): string;
+
+/**
+ * Channel closing configuration
+ */
+interface ChannelClosingConfig {
+    challengePeriod?: number;
+    gracePeriod?: number;
+    autoFinalize?: boolean;
+}
+/**
+ * Close initiation result
+ */
+interface CloseInitiationResult {
+    success: boolean;
+    error?: string;
+    challengeDeadline?: number;
+    finalCheckpoint?: ChannelCheckpoint;
+    settlementAmount?: {
+        payer: string;
+        payee: string;
+    };
+}
+/**
+ * Channel final settlement result
+ */
+interface ChannelSettlementResult {
+    success: boolean;
+    error?: string;
+    finalBalance: ChannelBalance;
+    settlementTxHash?: string;
+    gasCost?: string;
+}
+/**
+ * Channel closer - handles channel closing and settlement
+ */
+declare class ChannelCloser {
+    private config;
+    constructor(config?: ChannelClosingConfig);
+    /**
+     * Initiate channel close
+     */
+    initiateClose(stateMachine: ChannelStateMachine, initiator: string, signature: string): CloseInitiationResult;
+    /**
+     * Complete mutual close (both parties agree)
+     */
+    mutualClose(stateMachine: ChannelStateMachine, payerSignature: string, payeeSignature: string): CloseInitiationResult;
+    /**
+     * Finalize channel after challenge period
+     */
+    finalize(stateMachine: ChannelStateMachine): ChannelSettlementResult;
+    /**
+     * Validate close request
+     */
+    validateCloseRequest(channel: StreamingChannel, request: ChannelCloseRequest): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Get settlement amounts for on-chain execution
+     */
+    getSettlementAmounts(channel: StreamingChannel): {
+        payer: string;
+        payee: string;
+        fee: string;
+    };
+    /**
+     * Calculate time until channel can be finalized
+     */
+    getTimeUntilFinalization(channel: StreamingChannel): number;
+    /**
+     * Check if channel close can be challenged
+     */
+    canChallenge(channel: StreamingChannel): boolean;
+    private calculateFinalBalance;
+    private createFinalCheckpoint;
+    private validateCheckpoint;
+}
+/**
+ * Build on-chain close transaction data
+ */
+declare function buildCloseTransactionData(channel: StreamingChannel, checkpoint: ChannelCheckpoint): {
+    to: string;
+    data: string;
+    value: string;
+};
+
+/**
+ * Recovery configuration
+ */
+interface RecoveryConfig {
+    maxCheckpointsToKeep?: number;
+    verifySignatures?: boolean;
+    onChainFallback?: boolean;
+}
+/**
+ * Recovery result
+ */
+interface RecoveryResult {
+    success: boolean;
+    error?: string;
+    channel?: StreamingChannel;
+    stateMachine?: ChannelStateMachine;
+    recoveredFromCheckpoint?: ChannelCheckpoint;
+    dataLoss?: boolean;
+}
+/**
+ * Channel storage interface for recovery
+ */
+interface IChannelStorage {
+    getChannel(channelId: string): Promise<StreamingChannel | null>;
+    getCheckpoints(channelId: string): Promise<ChannelCheckpoint[]>;
+    getTransactions(channelId: string): Promise<FundingTransaction[]>;
+    getDisputes(channelId: string): Promise<ChannelDispute[]>;
+    getStateHistory(channelId: string): Promise<StateTransition[]>;
+}
+/**
+ * Channel recovery manager
+ */
+declare class ChannelRecovery {
+    private config;
+    private storage?;
+    constructor(config?: RecoveryConfig, storage?: IChannelStorage);
+    /**
+     * Recover channel from checkpoints
+     */
+    recoverFromCheckpoints(baseChannel: StreamingChannel, checkpoints: ChannelCheckpoint[]): RecoveryResult;
+    /**
+     * Full recovery from storage
+     */
+    recoverFromStorage(channelId: string): Promise<RecoveryResult>;
+    /**
+     * Export recovery data for backup
+     */
+    exportRecoveryData(channel: StreamingChannel, stateMachine: ChannelStateMachine): RecoveryData;
+    /**
+     * Import recovery data
+     */
+    importRecoveryData(data: RecoveryData): RecoveryResult;
+    /**
+     * Verify checkpoint integrity
+     */
+    verifyCheckpointChain(checkpoints: ChannelCheckpoint[]): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Prune old checkpoints keeping only recent ones
+     */
+    pruneCheckpoints(checkpoints: ChannelCheckpoint[]): ChannelCheckpoint[];
+    private isCheckpointValid;
+    private reconstructFromCheckpoint;
+    private recoverFromOnChain;
+    private createBaseChannelFromRecoveryData;
+}
+/**
+ * Create a state snapshot for backup
+ */
+declare function createStateSnapshot(_channel: StreamingChannel, stateMachine: ChannelStateMachine): string;
+/**
+ * Restore from state snapshot
+ */
+declare function restoreFromSnapshot(snapshotJson: string): RecoveryResult;
+
+export { type AssetId, type ChainId, ChannelBalance, ChannelCheckpoint, ChannelCloseRequest, ChannelCloser, type ChannelClosingConfig, ChannelConfig, ChannelCreateRequest, ChannelDispute, ChannelOpener, type ChannelOpeningConfig, type ChannelOpeningResult, ChannelParticipant, ChannelRecovery, type ChannelSettlementResult, ChannelState, ChannelStateMachine, type CloseInitiationResult, FundingTransaction, type IChannelStorage, type RecoveryConfig, RecoveryData, type RecoveryResult, type StateEvent, StateTransition, StreamingChannel, buildCloseTransactionData, calculateRequiredDeposit, createStateSnapshot, estimateChannelDuration, getChannelUtilization, isChannelActive, isChannelTerminal, restoreFromSnapshot };