import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../common";
export declare namespace StateChannel {
    type ChannelStateStruct = {
        status: BigNumberish;
        indexer: string;
        consumer: string;
        realTotal: BigNumberish;
        total: BigNumberish;
        spent: BigNumberish;
        expiredAt: BigNumberish;
        terminatedAt: BigNumberish;
        deploymentId: BytesLike;
        terminateByIndexer: boolean;
    };
    type ChannelStateStructOutput = [
        number,
        string,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        boolean
    ] & {
        status: number;
        indexer: string;
        consumer: string;
        realTotal: BigNumber;
        total: BigNumber;
        spent: BigNumber;
        expiredAt: BigNumber;
        terminatedAt: BigNumber;
        deploymentId: string;
        terminateByIndexer: boolean;
    };
    type QueryStateStruct = {
        channelId: BigNumberish;
        spent: BigNumberish;
        isFinal: boolean;
        indexerSign: BytesLike;
        consumerSign: BytesLike;
    };
    type QueryStateStructOutput = [
        BigNumber,
        BigNumber,
        boolean,
        string,
        string
    ] & {
        channelId: BigNumber;
        spent: BigNumber;
        isFinal: boolean;
        indexerSign: string;
        consumerSign: string;
    };
}
export interface StateChannelInterface extends utils.Interface {
    functions: {
        "channel(uint256)": FunctionFragment;
        "channelPrice(uint256)": FunctionFragment;
        "checkpoint((uint256,uint256,bool,bytes,bytes))": FunctionFragment;
        "claim(uint256)": FunctionFragment;
        "consumerContractWhitelist(address)": FunctionFragment;
        "extend(uint256,uint256,uint256,bytes,bytes,uint256)": FunctionFragment;
        "fund(uint256,uint256,uint256,bytes,bytes)": FunctionFragment;
        "initialize(address)": FunctionFragment;
        "open(uint256,address,address,uint256,uint256,uint256,bytes32,bytes,bytes,bytes)": FunctionFragment;
        "owner()": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "respond((uint256,uint256,bool,bytes,bytes))": FunctionFragment;
        "setConsumerContractWhitelist(address,bool)": FunctionFragment;
        "setSettings(address)": FunctionFragment;
        "setTerminateExpiration(uint256)": FunctionFragment;
        "settings()": FunctionFragment;
        "terminate((uint256,uint256,bool,bytes,bytes))": FunctionFragment;
        "terminateExpiration()": FunctionFragment;
        "terminateWithCurrentState(uint256)": FunctionFragment;
        "transferOwnership(address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "channel" | "channelPrice" | "checkpoint" | "claim" | "consumerContractWhitelist" | "extend" | "fund" | "initialize" | "open" | "owner" | "renounceOwnership" | "respond" | "setConsumerContractWhitelist" | "setSettings" | "setTerminateExpiration" | "settings" | "terminate" | "terminateExpiration" | "terminateWithCurrentState" | "transferOwnership"): FunctionFragment;
    encodeFunctionData(functionFragment: "channel", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "channelPrice", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "checkpoint", values: [StateChannel.QueryStateStruct]): string;
    encodeFunctionData(functionFragment: "claim", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "consumerContractWhitelist", values: [string]): string;
    encodeFunctionData(functionFragment: "extend", values: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BytesLike,
        BytesLike,
        BigNumberish
    ]): string;
    encodeFunctionData(functionFragment: "fund", values: [BigNumberish, BigNumberish, BigNumberish, BytesLike, BytesLike]): string;
    encodeFunctionData(functionFragment: "initialize", values: [string]): string;
    encodeFunctionData(functionFragment: "open", values: [
        BigNumberish,
        string,
        string,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BytesLike,
        BytesLike,
        BytesLike,
        BytesLike
    ]): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "respond", values: [StateChannel.QueryStateStruct]): string;
    encodeFunctionData(functionFragment: "setConsumerContractWhitelist", values: [string, boolean]): string;
    encodeFunctionData(functionFragment: "setSettings", values: [string]): string;
    encodeFunctionData(functionFragment: "setTerminateExpiration", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "settings", values?: undefined): string;
    encodeFunctionData(functionFragment: "terminate", values: [StateChannel.QueryStateStruct]): string;
    encodeFunctionData(functionFragment: "terminateExpiration", values?: undefined): string;
    encodeFunctionData(functionFragment: "terminateWithCurrentState", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
    decodeFunctionResult(functionFragment: "channel", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "channelPrice", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "checkpoint", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "consumerContractWhitelist", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "extend", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "fund", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "open", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "respond", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setConsumerContractWhitelist", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setSettings", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setTerminateExpiration", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "settings", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "terminate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "terminateExpiration", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "terminateWithCurrentState", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    events: {
        "ChannelCheckpoint(uint256,uint256,bool)": EventFragment;
        "ChannelExtend(uint256,uint256,uint256)": EventFragment;
        "ChannelFinalize(uint256,uint256,uint256)": EventFragment;
        "ChannelFund(uint256,uint256,uint256)": EventFragment;
        "ChannelLabor(bytes32,address,uint256)": EventFragment;
        "ChannelLabor2(uint256,bytes32,address,uint256)": EventFragment;
        "ChannelOpen(uint256,address,address,uint256,uint256,uint256,bytes32,bytes)": EventFragment;
        "ChannelTerminate(uint256,uint256,uint256,bool)": EventFragment;
        "ConsumerContractWhitelistChanged(address,bool)": EventFragment;
        "Initialized(uint8)": EventFragment;
        "OwnershipTransferred(address,address)": EventFragment;
        "Parameter(string,bytes)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "ChannelCheckpoint"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChannelExtend"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChannelFinalize"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChannelFund"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChannelLabor"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChannelLabor2"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChannelOpen"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChannelTerminate"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ConsumerContractWhitelistChanged"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Parameter"): EventFragment;
}
export interface ChannelCheckpointEventObject {
    channelId: BigNumber;
    spent: BigNumber;
    isFinal: boolean;
}
export type ChannelCheckpointEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    boolean
], ChannelCheckpointEventObject>;
export type ChannelCheckpointEventFilter = TypedEventFilter<ChannelCheckpointEvent>;
export interface ChannelExtendEventObject {
    channelId: BigNumber;
    expiredAt: BigNumber;
    price: BigNumber;
}
export type ChannelExtendEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber
], ChannelExtendEventObject>;
export type ChannelExtendEventFilter = TypedEventFilter<ChannelExtendEvent>;
export interface ChannelFinalizeEventObject {
    channelId: BigNumber;
    total: BigNumber;
    remain: BigNumber;
}
export type ChannelFinalizeEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber
], ChannelFinalizeEventObject>;
export type ChannelFinalizeEventFilter = TypedEventFilter<ChannelFinalizeEvent>;
export interface ChannelFundEventObject {
    channelId: BigNumber;
    realTotal: BigNumber;
    total: BigNumber;
}
export type ChannelFundEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber
], ChannelFundEventObject>;
export type ChannelFundEventFilter = TypedEventFilter<ChannelFundEvent>;
export interface ChannelLaborEventObject {
    deploymentId: string;
    indexer: string;
    amount: BigNumber;
}
export type ChannelLaborEvent = TypedEvent<[
    string,
    string,
    BigNumber
], ChannelLaborEventObject>;
export type ChannelLaborEventFilter = TypedEventFilter<ChannelLaborEvent>;
export interface ChannelLabor2EventObject {
    channelId: BigNumber;
    deploymentId: string;
    indexer: string;
    amount: BigNumber;
}
export type ChannelLabor2Event = TypedEvent<[
    BigNumber,
    string,
    string,
    BigNumber
], ChannelLabor2EventObject>;
export type ChannelLabor2EventFilter = TypedEventFilter<ChannelLabor2Event>;
export interface ChannelOpenEventObject {
    channelId: BigNumber;
    indexer: string;
    consumer: string;
    total: BigNumber;
    price: BigNumber;
    expiredAt: BigNumber;
    deploymentId: string;
    callback: string;
}
export type ChannelOpenEvent = TypedEvent<[
    BigNumber,
    string,
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    string,
    string
], ChannelOpenEventObject>;
export type ChannelOpenEventFilter = TypedEventFilter<ChannelOpenEvent>;
export interface ChannelTerminateEventObject {
    channelId: BigNumber;
    spent: BigNumber;
    terminatedAt: BigNumber;
    terminateByIndexer: boolean;
}
export type ChannelTerminateEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber,
    boolean
], ChannelTerminateEventObject>;
export type ChannelTerminateEventFilter = TypedEventFilter<ChannelTerminateEvent>;
export interface ConsumerContractWhitelistChangedEventObject {
    consumerContract: string;
    status: boolean;
}
export type ConsumerContractWhitelistChangedEvent = TypedEvent<[
    string,
    boolean
], ConsumerContractWhitelistChangedEventObject>;
export type ConsumerContractWhitelistChangedEventFilter = TypedEventFilter<ConsumerContractWhitelistChangedEvent>;
export interface InitializedEventObject {
    version: number;
}
export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface ParameterEventObject {
    name: string;
    value: string;
}
export type ParameterEvent = TypedEvent<[string, string], ParameterEventObject>;
export type ParameterEventFilter = TypedEventFilter<ParameterEvent>;
export interface StateChannel extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: StateChannelInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        channel(channelId: BigNumberish, overrides?: CallOverrides): Promise<[StateChannel.ChannelStateStructOutput]>;
        channelPrice(arg0: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
        checkpoint(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        claim(channelId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        consumerContractWhitelist(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;
        extend(channelId: BigNumberish, preExpirationAt: BigNumberish, expiration: BigNumberish, indexerSign: BytesLike, consumerSign: BytesLike, price: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        fund(channelId: BigNumberish, preTotal: BigNumberish, amount: BigNumberish, callback: BytesLike, sign: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        initialize(_settings: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        open(channelId: BigNumberish, indexer: string, consumer: string, amount: BigNumberish, price: BigNumberish, expiration: BigNumberish, deploymentId: BytesLike, callback: BytesLike, indexerSign: BytesLike, consumerSign: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        respond(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setConsumerContractWhitelist(consumerContract: string, status: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setSettings(_settings: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setTerminateExpiration(expiration: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        settings(overrides?: CallOverrides): Promise<[string]>;
        terminate(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        terminateExpiration(overrides?: CallOverrides): Promise<[BigNumber]>;
        terminateWithCurrentState(channelId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    channel(channelId: BigNumberish, overrides?: CallOverrides): Promise<StateChannel.ChannelStateStructOutput>;
    channelPrice(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    checkpoint(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    claim(channelId: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    consumerContractWhitelist(arg0: string, overrides?: CallOverrides): Promise<boolean>;
    extend(channelId: BigNumberish, preExpirationAt: BigNumberish, expiration: BigNumberish, indexerSign: BytesLike, consumerSign: BytesLike, price: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    fund(channelId: BigNumberish, preTotal: BigNumberish, amount: BigNumberish, callback: BytesLike, sign: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    initialize(_settings: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    open(channelId: BigNumberish, indexer: string, consumer: string, amount: BigNumberish, price: BigNumberish, expiration: BigNumberish, deploymentId: BytesLike, callback: BytesLike, indexerSign: BytesLike, consumerSign: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    owner(overrides?: CallOverrides): Promise<string>;
    renounceOwnership(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    respond(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setConsumerContractWhitelist(consumerContract: string, status: boolean, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setSettings(_settings: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setTerminateExpiration(expiration: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    settings(overrides?: CallOverrides): Promise<string>;
    terminate(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    terminateExpiration(overrides?: CallOverrides): Promise<BigNumber>;
    terminateWithCurrentState(channelId: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        channel(channelId: BigNumberish, overrides?: CallOverrides): Promise<StateChannel.ChannelStateStructOutput>;
        channelPrice(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        checkpoint(query: StateChannel.QueryStateStruct, overrides?: CallOverrides): Promise<void>;
        claim(channelId: BigNumberish, overrides?: CallOverrides): Promise<void>;
        consumerContractWhitelist(arg0: string, overrides?: CallOverrides): Promise<boolean>;
        extend(channelId: BigNumberish, preExpirationAt: BigNumberish, expiration: BigNumberish, indexerSign: BytesLike, consumerSign: BytesLike, price: BigNumberish, overrides?: CallOverrides): Promise<void>;
        fund(channelId: BigNumberish, preTotal: BigNumberish, amount: BigNumberish, callback: BytesLike, sign: BytesLike, overrides?: CallOverrides): Promise<void>;
        initialize(_settings: string, overrides?: CallOverrides): Promise<void>;
        open(channelId: BigNumberish, indexer: string, consumer: string, amount: BigNumberish, price: BigNumberish, expiration: BigNumberish, deploymentId: BytesLike, callback: BytesLike, indexerSign: BytesLike, consumerSign: BytesLike, overrides?: CallOverrides): Promise<void>;
        owner(overrides?: CallOverrides): Promise<string>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        respond(query: StateChannel.QueryStateStruct, overrides?: CallOverrides): Promise<void>;
        setConsumerContractWhitelist(consumerContract: string, status: boolean, overrides?: CallOverrides): Promise<void>;
        setSettings(_settings: string, overrides?: CallOverrides): Promise<void>;
        setTerminateExpiration(expiration: BigNumberish, overrides?: CallOverrides): Promise<void>;
        settings(overrides?: CallOverrides): Promise<string>;
        terminate(query: StateChannel.QueryStateStruct, overrides?: CallOverrides): Promise<void>;
        terminateExpiration(overrides?: CallOverrides): Promise<BigNumber>;
        terminateWithCurrentState(channelId: BigNumberish, overrides?: CallOverrides): Promise<void>;
        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "ChannelCheckpoint(uint256,uint256,bool)"(channelId?: BigNumberish | null, spent?: null, isFinal?: null): ChannelCheckpointEventFilter;
        ChannelCheckpoint(channelId?: BigNumberish | null, spent?: null, isFinal?: null): ChannelCheckpointEventFilter;
        "ChannelExtend(uint256,uint256,uint256)"(channelId?: BigNumberish | null, expiredAt?: null, price?: null): ChannelExtendEventFilter;
        ChannelExtend(channelId?: BigNumberish | null, expiredAt?: null, price?: null): ChannelExtendEventFilter;
        "ChannelFinalize(uint256,uint256,uint256)"(channelId?: BigNumberish | null, total?: null, remain?: null): ChannelFinalizeEventFilter;
        ChannelFinalize(channelId?: BigNumberish | null, total?: null, remain?: null): ChannelFinalizeEventFilter;
        "ChannelFund(uint256,uint256,uint256)"(channelId?: BigNumberish | null, realTotal?: null, total?: null): ChannelFundEventFilter;
        ChannelFund(channelId?: BigNumberish | null, realTotal?: null, total?: null): ChannelFundEventFilter;
        "ChannelLabor(bytes32,address,uint256)"(deploymentId?: null, indexer?: null, amount?: null): ChannelLaborEventFilter;
        ChannelLabor(deploymentId?: null, indexer?: null, amount?: null): ChannelLaborEventFilter;
        "ChannelLabor2(uint256,bytes32,address,uint256)"(channelId?: BigNumberish | null, deploymentId?: null, indexer?: null, amount?: null): ChannelLabor2EventFilter;
        ChannelLabor2(channelId?: BigNumberish | null, deploymentId?: null, indexer?: null, amount?: null): ChannelLabor2EventFilter;
        "ChannelOpen(uint256,address,address,uint256,uint256,uint256,bytes32,bytes)"(channelId?: BigNumberish | null, indexer?: null, consumer?: null, total?: null, price?: null, expiredAt?: null, deploymentId?: null, callback?: null): ChannelOpenEventFilter;
        ChannelOpen(channelId?: BigNumberish | null, indexer?: null, consumer?: null, total?: null, price?: null, expiredAt?: null, deploymentId?: null, callback?: null): ChannelOpenEventFilter;
        "ChannelTerminate(uint256,uint256,uint256,bool)"(channelId?: BigNumberish | null, spent?: null, terminatedAt?: null, terminateByIndexer?: null): ChannelTerminateEventFilter;
        ChannelTerminate(channelId?: BigNumberish | null, spent?: null, terminatedAt?: null, terminateByIndexer?: null): ChannelTerminateEventFilter;
        "ConsumerContractWhitelistChanged(address,bool)"(consumerContract?: null, status?: null): ConsumerContractWhitelistChangedEventFilter;
        ConsumerContractWhitelistChanged(consumerContract?: null, status?: null): ConsumerContractWhitelistChangedEventFilter;
        "Initialized(uint8)"(version?: null): InitializedEventFilter;
        Initialized(version?: null): InitializedEventFilter;
        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        "Parameter(string,bytes)"(name?: null, value?: null): ParameterEventFilter;
        Parameter(name?: null, value?: null): ParameterEventFilter;
    };
    estimateGas: {
        channel(channelId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        channelPrice(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        checkpoint(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        claim(channelId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        consumerContractWhitelist(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        extend(channelId: BigNumberish, preExpirationAt: BigNumberish, expiration: BigNumberish, indexerSign: BytesLike, consumerSign: BytesLike, price: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        fund(channelId: BigNumberish, preTotal: BigNumberish, amount: BigNumberish, callback: BytesLike, sign: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        initialize(_settings: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        open(channelId: BigNumberish, indexer: string, consumer: string, amount: BigNumberish, price: BigNumberish, expiration: BigNumberish, deploymentId: BytesLike, callback: BytesLike, indexerSign: BytesLike, consumerSign: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        respond(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setConsumerContractWhitelist(consumerContract: string, status: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setSettings(_settings: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setTerminateExpiration(expiration: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        settings(overrides?: CallOverrides): Promise<BigNumber>;
        terminate(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        terminateExpiration(overrides?: CallOverrides): Promise<BigNumber>;
        terminateWithCurrentState(channelId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        channel(channelId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        channelPrice(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        checkpoint(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        claim(channelId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        consumerContractWhitelist(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        extend(channelId: BigNumberish, preExpirationAt: BigNumberish, expiration: BigNumberish, indexerSign: BytesLike, consumerSign: BytesLike, price: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        fund(channelId: BigNumberish, preTotal: BigNumberish, amount: BigNumberish, callback: BytesLike, sign: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        initialize(_settings: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        open(channelId: BigNumberish, indexer: string, consumer: string, amount: BigNumberish, price: BigNumberish, expiration: BigNumberish, deploymentId: BytesLike, callback: BytesLike, indexerSign: BytesLike, consumerSign: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        respond(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setConsumerContractWhitelist(consumerContract: string, status: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setSettings(_settings: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setTerminateExpiration(expiration: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        settings(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        terminate(query: StateChannel.QueryStateStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        terminateExpiration(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        terminateWithCurrentState(channelId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}