import * as t from 'io-ts';
import { WithdrawConfirmation, WithdrawRequest } from '../messages';
import type { ActionType } from '../utils/actions';
import { Address, UInt } from '../utils/types';
export declare const newBlock: ((payload: {
    blockNumber: number;
}) => {
    readonly type: "block/new";
    readonly payload: {
        blockNumber: number;
    };
}) & {
    type: "block/new";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "block/new";
        readonly payload: {
            blockNumber: number;
        };
    };
    error: undefined;
};
export interface newBlock extends ActionType<typeof newBlock> {
}
export declare const blockTime: ((payload: {
    blockTime: number;
}) => {
    readonly type: "block/time";
    readonly payload: {
        blockTime: number;
    };
}) & {
    type: "block/time";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "block/time";
        readonly payload: {
            blockTime: number;
        };
    };
    error: undefined;
};
export interface blockTime extends ActionType<typeof blockTime> {
}
export declare const blockStale: ((payload: {
    stale: boolean;
}) => {
    readonly type: "block/stale";
    readonly payload: {
        stale: boolean;
    };
}) & {
    type: "block/stale";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "block/stale";
        readonly payload: {
            stale: boolean;
        };
    };
    error: undefined;
};
export interface blockStale extends ActionType<typeof blockStale> {
}
export declare const contractSettleTimeout: ((payload: number) => {
    readonly type: "contract/settleTimeout";
    readonly payload: number;
}) & {
    type: "contract/settleTimeout";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "contract/settleTimeout";
        readonly payload: number;
    };
    error: undefined;
};
export interface contractSettleTimeout extends ActionType<typeof contractSettleTimeout> {
}
/**
 * A new token network is detected in the TokenNetworkRegistry instance
 * fromBlock is only set on the first time, to fetch and handle past events
 */
export declare const tokenMonitored: ((payload: {
    token: Address;
    tokenNetwork: Address;
} & {
    fromBlock?: number | undefined;
    toBlock?: number | undefined;
}) => {
    readonly type: "token/monitored";
    readonly payload: {
        token: Address;
        tokenNetwork: Address;
    } & {
        fromBlock?: number | undefined;
        toBlock?: number | undefined;
    };
}) & {
    type: "token/monitored";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "token/monitored";
        readonly payload: {
            token: Address;
            tokenNetwork: Address;
        } & {
            fromBlock?: number | undefined;
            toBlock?: number | undefined;
        };
    };
    error: undefined;
};
export interface tokenMonitored extends ActionType<typeof tokenMonitored> {
}
/**
 * Channel actions receive ChannelId as 'meta' action property
 * This way, 'meta' can be used equally for request, success and error actions
 */
export declare const channelOpen: {
    readonly request: ((payload: {
        deposit?: UInt<32> | undefined;
    }, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/open/request";
        readonly payload: {
            deposit?: UInt<32> | undefined;
        };
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    }) & {
        type: "channel/open/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/open/request";
            readonly payload: {
                deposit?: UInt<32> | undefined;
            };
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
        };
        error: undefined;
    };
    readonly success: ((payload: {
        id: number;
        token: Address;
        isFirstParticipant: boolean;
        txHash: import("../utils/types").HexString<32>;
        txBlock: number;
        confirmed: boolean | undefined;
    }, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/open/success";
        readonly payload: {
            id: number;
            token: Address;
            isFirstParticipant: boolean;
            txHash: import("../utils/types").HexString<32>;
            txBlock: number;
            confirmed: boolean | undefined;
        };
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    }) & {
        type: "channel/open/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/open/success";
            readonly payload: {
                id: number;
                token: Address;
                isFirstParticipant: boolean;
                txHash: import("../utils/types").HexString<32>;
                txBlock: number;
                confirmed: boolean | undefined;
            };
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/open/failure";
        readonly payload: unknown;
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
        readonly error: true;
    }) & {
        type: "channel/open/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/open/failure";
            readonly payload: unknown;
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace channelOpen {
    interface request extends ActionType<typeof channelOpen.request> {
    }
    interface success extends ActionType<typeof channelOpen.success> {
    }
    interface failure extends ActionType<typeof channelOpen.failure> {
    }
}
export declare const channelMonitored: ((payload: {
    id: number;
}, meta: {
    tokenNetwork: Address;
    partner: Address;
}) => {
    readonly type: "channel/monitored";
    readonly payload: {
        id: number;
    };
    readonly meta: {
        tokenNetwork: Address;
        partner: Address;
    };
}) & {
    type: "channel/monitored";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "channel/monitored";
        readonly payload: {
            id: number;
        };
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    };
    error: undefined;
};
export interface channelMonitored extends ActionType<typeof channelMonitored> {
}
export declare const channelDeposit: {
    readonly request: ((payload: ({
        deposit: UInt<32>;
    } | {
        totalDeposit: UInt<32>;
    }) & {
        waitOpen?: true | undefined;
    }, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/deposit/request";
        readonly payload: ({
            deposit: UInt<32>;
        } | {
            totalDeposit: UInt<32>;
        }) & {
            waitOpen?: true | undefined;
        };
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    }) & {
        type: "channel/deposit/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/deposit/request";
            readonly payload: ({
                deposit: UInt<32>;
            } | {
                totalDeposit: UInt<32>;
            }) & {
                waitOpen?: true | undefined;
            };
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
        };
        error: undefined;
    };
    readonly success: ((payload: {
        id: number;
        participant: Address;
        totalDeposit: UInt<32>;
        txHash: import("../utils/types").HexString<32>;
        txBlock: number;
        confirmed: boolean | undefined;
    }, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/deposit/success";
        readonly payload: {
            id: number;
            participant: Address;
            totalDeposit: UInt<32>;
            txHash: import("../utils/types").HexString<32>;
            txBlock: number;
            confirmed: boolean | undefined;
        };
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    }) & {
        type: "channel/deposit/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/deposit/success";
            readonly payload: {
                id: number;
                participant: Address;
                totalDeposit: UInt<32>;
                txHash: import("../utils/types").HexString<32>;
                txBlock: number;
                confirmed: boolean | undefined;
            };
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/deposit/failure";
        readonly payload: unknown;
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
        readonly error: true;
    }) & {
        type: "channel/deposit/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/deposit/failure";
            readonly payload: unknown;
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace channelDeposit {
    interface request extends ActionType<typeof channelDeposit.request> {
    }
    interface success extends ActionType<typeof channelDeposit.success> {
    }
    interface failure extends ActionType<typeof channelDeposit.failure> {
    }
}
export declare const channelWithdrawn: ((payload: {
    id: number;
    participant: Address;
    totalWithdraw: UInt<32>;
    txHash: import("../utils/types").HexString<32>;
    txBlock: number;
    confirmed: boolean | undefined;
}, meta: {
    tokenNetwork: Address;
    partner: Address;
}) => {
    readonly type: "channel/withdraw/success";
    readonly payload: {
        id: number;
        participant: Address;
        totalWithdraw: UInt<32>;
        txHash: import("../utils/types").HexString<32>;
        txBlock: number;
        confirmed: boolean | undefined;
    };
    readonly meta: {
        tokenNetwork: Address;
        partner: Address;
    };
}) & {
    type: "channel/withdraw/success";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "channel/withdraw/success";
        readonly payload: {
            id: number;
            participant: Address;
            totalWithdraw: UInt<32>;
            txHash: import("../utils/types").HexString<32>;
            txBlock: number;
            confirmed: boolean | undefined;
        };
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    };
    error: undefined;
};
export interface channelWithdrawn extends ActionType<typeof channelWithdrawn> {
}
export declare const channelClose: {
    readonly request: ((payload: undefined, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/close/request";
        readonly payload: undefined;
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    }) & {
        type: "channel/close/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/close/request";
            readonly payload: undefined;
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
        };
        error: undefined;
    };
    readonly success: ((payload: {
        id: number;
        participant: Address;
        txHash: import("../utils/types").HexString<32>;
        txBlock: number;
        confirmed: boolean | undefined;
    }, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/close/success";
        readonly payload: {
            id: number;
            participant: Address;
            txHash: import("../utils/types").HexString<32>;
            txBlock: number;
            confirmed: boolean | undefined;
        };
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    }) & {
        type: "channel/close/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/close/success";
            readonly payload: {
                id: number;
                participant: Address;
                txHash: import("../utils/types").HexString<32>;
                txBlock: number;
                confirmed: boolean | undefined;
            };
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/close/failure";
        readonly payload: unknown;
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
        readonly error: true;
    }) & {
        type: "channel/close/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/close/failure";
            readonly payload: unknown;
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace channelClose {
    interface request extends ActionType<typeof channelClose.request> {
    }
    interface success extends ActionType<typeof channelClose.success> {
    }
    interface failure extends ActionType<typeof channelClose.failure> {
    }
}
export declare const channelSettleable: ((payload: {
    settleableBlock: number;
}, meta: {
    tokenNetwork: Address;
    partner: Address;
}) => {
    readonly type: "channel/settleable";
    readonly payload: {
        settleableBlock: number;
    };
    readonly meta: {
        tokenNetwork: Address;
        partner: Address;
    };
}) & {
    type: "channel/settleable";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "channel/settleable";
        readonly payload: {
            settleableBlock: number;
        };
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    };
    error: undefined;
};
export interface channelSettleable extends ActionType<typeof channelSettleable> {
}
export declare const channelSettle: {
    readonly request: ((payload: {
        coopSettle: [[WithdrawRequest & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>, WithdrawConfirmation & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>], [WithdrawRequest & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>, WithdrawConfirmation & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>]];
    } | undefined, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/settle/request";
        readonly payload: {
            coopSettle: [[WithdrawRequest & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>, WithdrawConfirmation & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>], [WithdrawRequest & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>, WithdrawConfirmation & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>]];
        } | undefined;
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    }) & {
        type: "channel/settle/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/settle/request";
            readonly payload: {
                coopSettle: [[WithdrawRequest & Readonly<{
                    signature: import("../utils/types").HexString<65>;
                }>, WithdrawConfirmation & Readonly<{
                    signature: import("../utils/types").HexString<65>;
                }>], [WithdrawRequest & Readonly<{
                    signature: import("../utils/types").HexString<65>;
                }>, WithdrawConfirmation & Readonly<{
                    signature: import("../utils/types").HexString<65>;
                }>]];
            } | undefined;
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
        };
        error: undefined;
    };
    readonly success: ((payload: {
        id: number;
        txHash: import("../utils/types").HexString<32>;
        txBlock: number;
        confirmed: boolean | undefined;
    } & {
        locks?: readonly ({
            amount: UInt<32>;
            expiration: UInt<32>;
            secrethash: import("../utils/types").HexString<32>;
        } & {
            registered?: true | undefined;
        })[] | undefined;
    }, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/settle/success";
        readonly payload: {
            id: number;
            txHash: import("../utils/types").HexString<32>;
            txBlock: number;
            confirmed: boolean | undefined;
        } & {
            locks?: readonly ({
                amount: UInt<32>;
                expiration: UInt<32>;
                secrethash: import("../utils/types").HexString<32>;
            } & {
                registered?: true | undefined;
            })[] | undefined;
        };
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
    }) & {
        type: "channel/settle/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/settle/success";
            readonly payload: {
                id: number;
                txHash: import("../utils/types").HexString<32>;
                txBlock: number;
                confirmed: boolean | undefined;
            } & {
                locks?: readonly ({
                    amount: UInt<32>;
                    expiration: UInt<32>;
                    secrethash: import("../utils/types").HexString<32>;
                } & {
                    registered?: true | undefined;
                })[] | undefined;
            };
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        tokenNetwork: Address;
        partner: Address;
    }) => {
        readonly type: "channel/settle/failure";
        readonly payload: unknown;
        readonly meta: {
            tokenNetwork: Address;
            partner: Address;
        };
        readonly error: true;
    }) & {
        type: "channel/settle/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "channel/settle/failure";
            readonly payload: unknown;
            readonly meta: {
                tokenNetwork: Address;
                partner: Address;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace channelSettle {
    interface request extends ActionType<typeof channelSettle.request> {
    }
    interface success extends ActionType<typeof channelSettle.success> {
    }
    interface failure extends ActionType<typeof channelSettle.failure> {
    }
}