import { Address, ContractState, TestContractResult, HexString, ContractFactory, CallContractParams, CallContractResult, TestContractParams, ContractInstance } from "@alephium/web3";
export declare namespace TokenBridgeForChainTypes {
    type Fields = {
        governance: HexString;
        localChainId: bigint;
        localTokenBridgeId: HexString;
        remoteChainId: bigint;
        remoteTokenBridgeId: HexString;
        start: bigint;
        firstNext256: bigint;
        secondNext256: bigint;
        unexecutedSequenceTemplateId: HexString;
        sendSequence: bigint;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        nextSendSequence: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
}
declare class Factory extends ContractFactory<TokenBridgeForChainInstance, TokenBridgeForChainTypes.Fields> {
    at(address: string): TokenBridgeForChainInstance;
    tests: {
        setExecuted: (params: TestContractParams<TokenBridgeForChainTypes.Fields, {
            offset: bigint;
            current: bigint;
        }>) => Promise<TestContractResult<bigint>>;
        compact: (params: Omit<TestContractParams<TokenBridgeForChainTypes.Fields, never>, "testArgs">) => Promise<TestContractResult<null>>;
        checkSequenceInSubContract: (params: TestContractParams<TokenBridgeForChainTypes.Fields, {
            seq: bigint;
        }>) => Promise<TestContractResult<null>>;
        checkSequence: (params: TestContractParams<TokenBridgeForChainTypes.Fields, {
            seq: bigint;
        }>) => Promise<TestContractResult<boolean>>;
        nextSendSequence: (params: Omit<TestContractParams<TokenBridgeForChainTypes.Fields, never>, "testArgs">) => Promise<TestContractResult<bigint>>;
        checkCompleteTransfer: (params: TestContractParams<TokenBridgeForChainTypes.Fields, {
            vaa: HexString;
        }>) => Promise<TestContractResult<[boolean, HexString]>>;
        parseCompleteTransfer: (params: TestContractParams<TokenBridgeForChainTypes.Fields, {
            payload: HexString;
        }>) => Promise<TestContractResult<[bigint, HexString, bigint, Address, bigint]>>;
        completeTransfer: (params: TestContractParams<TokenBridgeForChainTypes.Fields, {
            vaa: HexString;
            caller: Address;
        }>) => Promise<TestContractResult<null>>;
        destroyUnexecutedSequenceContracts: (params: TestContractParams<TokenBridgeForChainTypes.Fields, {
            paths: HexString;
        }>) => Promise<TestContractResult<null>>;
        deposit: (params: TestContractParams<TokenBridgeForChainTypes.Fields, {
            from: Address;
            alphAmount: bigint;
        }>) => Promise<TestContractResult<null>>;
        withdraw: (params: TestContractParams<TokenBridgeForChainTypes.Fields, {
            alphAmount: bigint;
        }>) => Promise<TestContractResult<null>>;
    };
}
export declare const TokenBridgeForChain: Factory;
export declare class TokenBridgeForChainInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<TokenBridgeForChainTypes.State>;
    methods: {
        nextSendSequence: (params?: Omit<CallContractParams<{}>, "args"> | undefined) => Promise<TokenBridgeForChainTypes.CallMethodResult<"nextSendSequence">>;
    };
    multicall<Calls extends TokenBridgeForChainTypes.MultiCallParams>(calls: Calls): Promise<TokenBridgeForChainTypes.MultiCallResults<Calls>>;
}
export {};
