import { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import { Listener, Provider } from "@ethersproject/providers";
import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
export interface BPoolInterface extends utils.Interface {
    functions: {
        "BONE()": FunctionFragment;
        "BPOW_PRECISION()": FunctionFragment;
        "EXIT_FEE()": FunctionFragment;
        "INIT_POOL_SUPPLY()": FunctionFragment;
        "MAX_BOUND_TOKENS()": FunctionFragment;
        "MAX_BPOW_BASE()": FunctionFragment;
        "MAX_FEE()": FunctionFragment;
        "MAX_IN_RATIO()": FunctionFragment;
        "MAX_OUT_RATIO()": FunctionFragment;
        "MAX_TOTAL_WEIGHT()": FunctionFragment;
        "MAX_WEIGHT()": FunctionFragment;
        "MIN_BALANCE()": FunctionFragment;
        "MIN_BOUND_TOKENS()": FunctionFragment;
        "MIN_BPOW_BASE()": FunctionFragment;
        "MIN_FEE()": FunctionFragment;
        "MIN_WEIGHT()": FunctionFragment;
        "allowance(address,address)": FunctionFragment;
        "approve(address,uint256)": FunctionFragment;
        "balanceOf(address)": FunctionFragment;
        "bind(address,uint256,uint256)": FunctionFragment;
        "calcInGivenOut(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
        "calcOutGivenIn(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
        "calcPoolInGivenSingleOut(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
        "calcPoolOutGivenSingleIn(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
        "calcSingleInGivenPoolOut(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
        "calcSingleOutGivenPoolIn(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
        "calcSpotPrice(uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
        "decimals()": FunctionFragment;
        "decreaseApproval(address,uint256)": FunctionFragment;
        "exitPool(uint256,uint256[])": FunctionFragment;
        "exitswapExternAmountOut(address,uint256,uint256)": FunctionFragment;
        "exitswapPoolAmountIn(address,uint256,uint256)": FunctionFragment;
        "finalize()": FunctionFragment;
        "getBalance(address)": FunctionFragment;
        "getColor()": FunctionFragment;
        "getController()": FunctionFragment;
        "getCurrentTokens()": FunctionFragment;
        "getDenormalizedWeight(address)": FunctionFragment;
        "getFinalTokens()": FunctionFragment;
        "getNormalizedWeight(address)": FunctionFragment;
        "getNumTokens()": FunctionFragment;
        "getSpotPrice(address,address)": FunctionFragment;
        "getSpotPriceSansFee(address,address)": FunctionFragment;
        "getSwapFee()": FunctionFragment;
        "getTotalDenormalizedWeight()": FunctionFragment;
        "gulp(address)": FunctionFragment;
        "increaseApproval(address,uint256)": FunctionFragment;
        "isBound(address)": FunctionFragment;
        "isFinalized()": FunctionFragment;
        "isPublicSwap()": FunctionFragment;
        "joinPool(uint256,uint256[])": FunctionFragment;
        "joinswapExternAmountIn(address,uint256,uint256)": FunctionFragment;
        "joinswapPoolAmountOut(address,uint256,uint256)": FunctionFragment;
        "name()": FunctionFragment;
        "rebind(address,uint256,uint256)": FunctionFragment;
        "setController(address)": FunctionFragment;
        "setPublicSwap(bool)": FunctionFragment;
        "setSwapFee(uint256)": FunctionFragment;
        "swapExactAmountIn(address,uint256,address,uint256,uint256)": FunctionFragment;
        "swapExactAmountOut(address,uint256,address,uint256,uint256)": FunctionFragment;
        "symbol()": FunctionFragment;
        "totalSupply()": FunctionFragment;
        "transfer(address,uint256)": FunctionFragment;
        "transferFrom(address,address,uint256)": FunctionFragment;
        "unbind(address)": FunctionFragment;
    };
    encodeFunctionData(functionFragment: "BONE", values?: undefined): string;
    encodeFunctionData(functionFragment: "BPOW_PRECISION", values?: undefined): string;
    encodeFunctionData(functionFragment: "EXIT_FEE", values?: undefined): string;
    encodeFunctionData(functionFragment: "INIT_POOL_SUPPLY", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_BOUND_TOKENS", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_BPOW_BASE", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_FEE", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_IN_RATIO", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_OUT_RATIO", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_TOTAL_WEIGHT", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_WEIGHT", values?: undefined): string;
    encodeFunctionData(functionFragment: "MIN_BALANCE", values?: undefined): string;
    encodeFunctionData(functionFragment: "MIN_BOUND_TOKENS", values?: undefined): string;
    encodeFunctionData(functionFragment: "MIN_BPOW_BASE", values?: undefined): string;
    encodeFunctionData(functionFragment: "MIN_FEE", values?: undefined): string;
    encodeFunctionData(functionFragment: "MIN_WEIGHT", values?: undefined): string;
    encodeFunctionData(functionFragment: "allowance", values: [string, string]): string;
    encodeFunctionData(functionFragment: "approve", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
    encodeFunctionData(functionFragment: "bind", values: [string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "calcInGivenOut", values: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish
    ]): string;
    encodeFunctionData(functionFragment: "calcOutGivenIn", values: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish
    ]): string;
    encodeFunctionData(functionFragment: "calcPoolInGivenSingleOut", values: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish
    ]): string;
    encodeFunctionData(functionFragment: "calcPoolOutGivenSingleIn", values: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish
    ]): string;
    encodeFunctionData(functionFragment: "calcSingleInGivenPoolOut", values: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish
    ]): string;
    encodeFunctionData(functionFragment: "calcSingleOutGivenPoolIn", values: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish
    ]): string;
    encodeFunctionData(functionFragment: "calcSpotPrice", values: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish
    ]): string;
    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
    encodeFunctionData(functionFragment: "decreaseApproval", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "exitPool", values: [BigNumberish, BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "exitswapExternAmountOut", values: [string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "exitswapPoolAmountIn", values: [string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "finalize", values?: undefined): string;
    encodeFunctionData(functionFragment: "getBalance", values: [string]): string;
    encodeFunctionData(functionFragment: "getColor", values?: undefined): string;
    encodeFunctionData(functionFragment: "getController", values?: undefined): string;
    encodeFunctionData(functionFragment: "getCurrentTokens", values?: undefined): string;
    encodeFunctionData(functionFragment: "getDenormalizedWeight", values: [string]): string;
    encodeFunctionData(functionFragment: "getFinalTokens", values?: undefined): string;
    encodeFunctionData(functionFragment: "getNormalizedWeight", values: [string]): string;
    encodeFunctionData(functionFragment: "getNumTokens", values?: undefined): string;
    encodeFunctionData(functionFragment: "getSpotPrice", values: [string, string]): string;
    encodeFunctionData(functionFragment: "getSpotPriceSansFee", values: [string, string]): string;
    encodeFunctionData(functionFragment: "getSwapFee", values?: undefined): string;
    encodeFunctionData(functionFragment: "getTotalDenormalizedWeight", values?: undefined): string;
    encodeFunctionData(functionFragment: "gulp", values: [string]): string;
    encodeFunctionData(functionFragment: "increaseApproval", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "isBound", values: [string]): string;
    encodeFunctionData(functionFragment: "isFinalized", values?: undefined): string;
    encodeFunctionData(functionFragment: "isPublicSwap", values?: undefined): string;
    encodeFunctionData(functionFragment: "joinPool", values: [BigNumberish, BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "joinswapExternAmountIn", values: [string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "joinswapPoolAmountOut", values: [string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "name", values?: undefined): string;
    encodeFunctionData(functionFragment: "rebind", values: [string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "setController", values: [string]): string;
    encodeFunctionData(functionFragment: "setPublicSwap", values: [boolean]): string;
    encodeFunctionData(functionFragment: "setSwapFee", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "swapExactAmountIn", values: [string, BigNumberish, string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "swapExactAmountOut", values: [string, BigNumberish, string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
    encodeFunctionData(functionFragment: "transfer", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "transferFrom", values: [string, string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "unbind", values: [string]): string;
    decodeFunctionResult(functionFragment: "BONE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "BPOW_PRECISION", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "EXIT_FEE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "INIT_POOL_SUPPLY", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_BOUND_TOKENS", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_BPOW_BASE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_FEE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_IN_RATIO", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_OUT_RATIO", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_TOTAL_WEIGHT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_WEIGHT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MIN_BALANCE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MIN_BOUND_TOKENS", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MIN_BPOW_BASE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MIN_FEE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MIN_WEIGHT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "bind", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calcInGivenOut", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calcOutGivenIn", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calcPoolInGivenSingleOut", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calcPoolOutGivenSingleIn", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calcSingleInGivenPoolOut", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calcSingleOutGivenPoolIn", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calcSpotPrice", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "decreaseApproval", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "exitPool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "exitswapExternAmountOut", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "exitswapPoolAmountIn", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "finalize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getColor", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getController", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getCurrentTokens", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getDenormalizedWeight", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getFinalTokens", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getNormalizedWeight", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getNumTokens", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getSpotPrice", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getSpotPriceSansFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getSwapFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getTotalDenormalizedWeight", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "gulp", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "increaseApproval", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isBound", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isFinalized", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isPublicSwap", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "joinPool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "joinswapExternAmountIn", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "joinswapPoolAmountOut", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rebind", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setController", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setPublicSwap", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setSwapFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swapExactAmountIn", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swapExactAmountOut", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unbind", data: BytesLike): Result;
    events: {
        "Approval(address,address,uint256)": EventFragment;
        "LOG_CALL(bytes4,address,bytes)": EventFragment;
        "LOG_EXIT(address,address,uint256)": EventFragment;
        "LOG_JOIN(address,address,uint256)": EventFragment;
        "LOG_SWAP(address,address,address,uint256,uint256)": EventFragment;
        "Transfer(address,address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "LOG_CALL"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "LOG_EXIT"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "LOG_JOIN"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "LOG_SWAP"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
}
export declare type ApprovalEvent = TypedEvent<[
    string,
    string,
    BigNumber
], {
    src: string;
    dst: string;
    amt: BigNumber;
}>;
export declare type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
export declare type LOG_CALLEvent = TypedEvent<[
    string,
    string,
    string
], {
    sig: string;
    caller: string;
    data: string;
}>;
export declare type LOG_CALLEventFilter = TypedEventFilter<LOG_CALLEvent>;
export declare type LOG_EXITEvent = TypedEvent<[
    string,
    string,
    BigNumber
], {
    caller: string;
    tokenOut: string;
    tokenAmountOut: BigNumber;
}>;
export declare type LOG_EXITEventFilter = TypedEventFilter<LOG_EXITEvent>;
export declare type LOG_JOINEvent = TypedEvent<[
    string,
    string,
    BigNumber
], {
    caller: string;
    tokenIn: string;
    tokenAmountIn: BigNumber;
}>;
export declare type LOG_JOINEventFilter = TypedEventFilter<LOG_JOINEvent>;
export declare type LOG_SWAPEvent = TypedEvent<[
    string,
    string,
    string,
    BigNumber,
    BigNumber
], {
    caller: string;
    tokenIn: string;
    tokenOut: string;
    tokenAmountIn: BigNumber;
    tokenAmountOut: BigNumber;
}>;
export declare type LOG_SWAPEventFilter = TypedEventFilter<LOG_SWAPEvent>;
export declare type TransferEvent = TypedEvent<[
    string,
    string,
    BigNumber
], {
    src: string;
    dst: string;
    amt: BigNumber;
}>;
export declare type TransferEventFilter = TypedEventFilter<TransferEvent>;
export interface BPool extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: BPoolInterface;
    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: {
        BONE(overrides?: CallOverrides): Promise<[BigNumber]>;
        BPOW_PRECISION(overrides?: CallOverrides): Promise<[BigNumber]>;
        EXIT_FEE(overrides?: CallOverrides): Promise<[BigNumber]>;
        INIT_POOL_SUPPLY(overrides?: CallOverrides): Promise<[BigNumber]>;
        MAX_BOUND_TOKENS(overrides?: CallOverrides): Promise<[BigNumber]>;
        MAX_BPOW_BASE(overrides?: CallOverrides): Promise<[BigNumber]>;
        MAX_FEE(overrides?: CallOverrides): Promise<[BigNumber]>;
        MAX_IN_RATIO(overrides?: CallOverrides): Promise<[BigNumber]>;
        MAX_OUT_RATIO(overrides?: CallOverrides): Promise<[BigNumber]>;
        MAX_TOTAL_WEIGHT(overrides?: CallOverrides): Promise<[BigNumber]>;
        MAX_WEIGHT(overrides?: CallOverrides): Promise<[BigNumber]>;
        MIN_BALANCE(overrides?: CallOverrides): Promise<[BigNumber]>;
        MIN_BOUND_TOKENS(overrides?: CallOverrides): Promise<[BigNumber]>;
        MIN_BPOW_BASE(overrides?: CallOverrides): Promise<[BigNumber]>;
        MIN_FEE(overrides?: CallOverrides): Promise<[BigNumber]>;
        MIN_WEIGHT(overrides?: CallOverrides): Promise<[BigNumber]>;
        allowance(src: string, dst: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        approve(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        balanceOf(whom: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        bind(token: string, balance: BigNumberish, denorm: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        calcInGivenOut(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, tokenAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
            tokenAmountIn: BigNumber;
        }>;
        calcOutGivenIn(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, tokenAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
            tokenAmountOut: BigNumber;
        }>;
        calcPoolInGivenSingleOut(tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, tokenAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
            poolAmountIn: BigNumber;
        }>;
        calcPoolOutGivenSingleIn(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, tokenAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
            poolAmountOut: BigNumber;
        }>;
        calcSingleInGivenPoolOut(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, poolAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
            tokenAmountIn: BigNumber;
        }>;
        calcSingleOutGivenPoolIn(tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, poolAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
            tokenAmountOut: BigNumber;
        }>;
        calcSpotPrice(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
            spotPrice: BigNumber;
        }>;
        decimals(overrides?: CallOverrides): Promise<[number]>;
        decreaseApproval(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        exitPool(poolAmountIn: BigNumberish, minAmountsOut: BigNumberish[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        exitswapExternAmountOut(tokenOut: string, tokenAmountOut: BigNumberish, maxPoolAmountIn: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        exitswapPoolAmountIn(tokenOut: string, poolAmountIn: BigNumberish, minAmountOut: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        finalize(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        getBalance(token: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        getColor(overrides?: CallOverrides): Promise<[string]>;
        getController(overrides?: CallOverrides): Promise<[string]>;
        getCurrentTokens(overrides?: CallOverrides): Promise<[string[]] & {
            tokens: string[];
        }>;
        getDenormalizedWeight(token: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        getFinalTokens(overrides?: CallOverrides): Promise<[string[]] & {
            tokens: string[];
        }>;
        getNormalizedWeight(token: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        getNumTokens(overrides?: CallOverrides): Promise<[BigNumber]>;
        getSpotPrice(tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<[BigNumber] & {
            spotPrice: BigNumber;
        }>;
        getSpotPriceSansFee(tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<[BigNumber] & {
            spotPrice: BigNumber;
        }>;
        getSwapFee(overrides?: CallOverrides): Promise<[BigNumber]>;
        getTotalDenormalizedWeight(overrides?: CallOverrides): Promise<[BigNumber]>;
        gulp(token: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        increaseApproval(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        isBound(t: string, overrides?: CallOverrides): Promise<[boolean]>;
        isFinalized(overrides?: CallOverrides): Promise<[boolean]>;
        isPublicSwap(overrides?: CallOverrides): Promise<[boolean]>;
        joinPool(poolAmountOut: BigNumberish, maxAmountsIn: BigNumberish[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        joinswapExternAmountIn(tokenIn: string, tokenAmountIn: BigNumberish, minPoolAmountOut: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        joinswapPoolAmountOut(tokenIn: string, poolAmountOut: BigNumberish, maxAmountIn: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        name(overrides?: CallOverrides): Promise<[string]>;
        rebind(token: string, balance: BigNumberish, denorm: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        setController(manager: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        setPublicSwap(public_: boolean, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        setSwapFee(swapFee: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        swapExactAmountIn(tokenIn: string, tokenAmountIn: BigNumberish, tokenOut: string, minAmountOut: BigNumberish, maxPrice: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        swapExactAmountOut(tokenIn: string, maxAmountIn: BigNumberish, tokenOut: string, tokenAmountOut: BigNumberish, maxPrice: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        symbol(overrides?: CallOverrides): Promise<[string]>;
        totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
        transfer(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        transferFrom(src: string, dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        unbind(token: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
    };
    BONE(overrides?: CallOverrides): Promise<BigNumber>;
    BPOW_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
    EXIT_FEE(overrides?: CallOverrides): Promise<BigNumber>;
    INIT_POOL_SUPPLY(overrides?: CallOverrides): Promise<BigNumber>;
    MAX_BOUND_TOKENS(overrides?: CallOverrides): Promise<BigNumber>;
    MAX_BPOW_BASE(overrides?: CallOverrides): Promise<BigNumber>;
    MAX_FEE(overrides?: CallOverrides): Promise<BigNumber>;
    MAX_IN_RATIO(overrides?: CallOverrides): Promise<BigNumber>;
    MAX_OUT_RATIO(overrides?: CallOverrides): Promise<BigNumber>;
    MAX_TOTAL_WEIGHT(overrides?: CallOverrides): Promise<BigNumber>;
    MAX_WEIGHT(overrides?: CallOverrides): Promise<BigNumber>;
    MIN_BALANCE(overrides?: CallOverrides): Promise<BigNumber>;
    MIN_BOUND_TOKENS(overrides?: CallOverrides): Promise<BigNumber>;
    MIN_BPOW_BASE(overrides?: CallOverrides): Promise<BigNumber>;
    MIN_FEE(overrides?: CallOverrides): Promise<BigNumber>;
    MIN_WEIGHT(overrides?: CallOverrides): Promise<BigNumber>;
    allowance(src: string, dst: string, overrides?: CallOverrides): Promise<BigNumber>;
    approve(dst: string, amt: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    balanceOf(whom: string, overrides?: CallOverrides): Promise<BigNumber>;
    bind(token: string, balance: BigNumberish, denorm: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    calcInGivenOut(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, tokenAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    calcOutGivenIn(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, tokenAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    calcPoolInGivenSingleOut(tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, tokenAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    calcPoolOutGivenSingleIn(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, tokenAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    calcSingleInGivenPoolOut(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, poolAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    calcSingleOutGivenPoolIn(tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, poolAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    calcSpotPrice(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    decimals(overrides?: CallOverrides): Promise<number>;
    decreaseApproval(dst: string, amt: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    exitPool(poolAmountIn: BigNumberish, minAmountsOut: BigNumberish[], overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    exitswapExternAmountOut(tokenOut: string, tokenAmountOut: BigNumberish, maxPoolAmountIn: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    exitswapPoolAmountIn(tokenOut: string, poolAmountIn: BigNumberish, minAmountOut: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    finalize(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    getBalance(token: string, overrides?: CallOverrides): Promise<BigNumber>;
    getColor(overrides?: CallOverrides): Promise<string>;
    getController(overrides?: CallOverrides): Promise<string>;
    getCurrentTokens(overrides?: CallOverrides): Promise<string[]>;
    getDenormalizedWeight(token: string, overrides?: CallOverrides): Promise<BigNumber>;
    getFinalTokens(overrides?: CallOverrides): Promise<string[]>;
    getNormalizedWeight(token: string, overrides?: CallOverrides): Promise<BigNumber>;
    getNumTokens(overrides?: CallOverrides): Promise<BigNumber>;
    getSpotPrice(tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<BigNumber>;
    getSpotPriceSansFee(tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<BigNumber>;
    getSwapFee(overrides?: CallOverrides): Promise<BigNumber>;
    getTotalDenormalizedWeight(overrides?: CallOverrides): Promise<BigNumber>;
    gulp(token: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    increaseApproval(dst: string, amt: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    isBound(t: string, overrides?: CallOverrides): Promise<boolean>;
    isFinalized(overrides?: CallOverrides): Promise<boolean>;
    isPublicSwap(overrides?: CallOverrides): Promise<boolean>;
    joinPool(poolAmountOut: BigNumberish, maxAmountsIn: BigNumberish[], overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    joinswapExternAmountIn(tokenIn: string, tokenAmountIn: BigNumberish, minPoolAmountOut: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    joinswapPoolAmountOut(tokenIn: string, poolAmountOut: BigNumberish, maxAmountIn: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    name(overrides?: CallOverrides): Promise<string>;
    rebind(token: string, balance: BigNumberish, denorm: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    setController(manager: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    setPublicSwap(public_: boolean, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    setSwapFee(swapFee: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    swapExactAmountIn(tokenIn: string, tokenAmountIn: BigNumberish, tokenOut: string, minAmountOut: BigNumberish, maxPrice: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    swapExactAmountOut(tokenIn: string, maxAmountIn: BigNumberish, tokenOut: string, tokenAmountOut: BigNumberish, maxPrice: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    symbol(overrides?: CallOverrides): Promise<string>;
    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
    transfer(dst: string, amt: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    transferFrom(src: string, dst: string, amt: BigNumberish, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    unbind(token: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        BONE(overrides?: CallOverrides): Promise<BigNumber>;
        BPOW_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
        EXIT_FEE(overrides?: CallOverrides): Promise<BigNumber>;
        INIT_POOL_SUPPLY(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_BOUND_TOKENS(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_BPOW_BASE(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_FEE(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_IN_RATIO(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_OUT_RATIO(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_TOTAL_WEIGHT(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_WEIGHT(overrides?: CallOverrides): Promise<BigNumber>;
        MIN_BALANCE(overrides?: CallOverrides): Promise<BigNumber>;
        MIN_BOUND_TOKENS(overrides?: CallOverrides): Promise<BigNumber>;
        MIN_BPOW_BASE(overrides?: CallOverrides): Promise<BigNumber>;
        MIN_FEE(overrides?: CallOverrides): Promise<BigNumber>;
        MIN_WEIGHT(overrides?: CallOverrides): Promise<BigNumber>;
        allowance(src: string, dst: string, overrides?: CallOverrides): Promise<BigNumber>;
        approve(dst: string, amt: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        balanceOf(whom: string, overrides?: CallOverrides): Promise<BigNumber>;
        bind(token: string, balance: BigNumberish, denorm: BigNumberish, overrides?: CallOverrides): Promise<void>;
        calcInGivenOut(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, tokenAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcOutGivenIn(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, tokenAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcPoolInGivenSingleOut(tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, tokenAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcPoolOutGivenSingleIn(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, tokenAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcSingleInGivenPoolOut(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, poolAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcSingleOutGivenPoolIn(tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, poolAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcSpotPrice(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        decimals(overrides?: CallOverrides): Promise<number>;
        decreaseApproval(dst: string, amt: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        exitPool(poolAmountIn: BigNumberish, minAmountsOut: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        exitswapExternAmountOut(tokenOut: string, tokenAmountOut: BigNumberish, maxPoolAmountIn: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        exitswapPoolAmountIn(tokenOut: string, poolAmountIn: BigNumberish, minAmountOut: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        finalize(overrides?: CallOverrides): Promise<void>;
        getBalance(token: string, overrides?: CallOverrides): Promise<BigNumber>;
        getColor(overrides?: CallOverrides): Promise<string>;
        getController(overrides?: CallOverrides): Promise<string>;
        getCurrentTokens(overrides?: CallOverrides): Promise<string[]>;
        getDenormalizedWeight(token: string, overrides?: CallOverrides): Promise<BigNumber>;
        getFinalTokens(overrides?: CallOverrides): Promise<string[]>;
        getNormalizedWeight(token: string, overrides?: CallOverrides): Promise<BigNumber>;
        getNumTokens(overrides?: CallOverrides): Promise<BigNumber>;
        getSpotPrice(tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<BigNumber>;
        getSpotPriceSansFee(tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<BigNumber>;
        getSwapFee(overrides?: CallOverrides): Promise<BigNumber>;
        getTotalDenormalizedWeight(overrides?: CallOverrides): Promise<BigNumber>;
        gulp(token: string, overrides?: CallOverrides): Promise<void>;
        increaseApproval(dst: string, amt: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        isBound(t: string, overrides?: CallOverrides): Promise<boolean>;
        isFinalized(overrides?: CallOverrides): Promise<boolean>;
        isPublicSwap(overrides?: CallOverrides): Promise<boolean>;
        joinPool(poolAmountOut: BigNumberish, maxAmountsIn: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        joinswapExternAmountIn(tokenIn: string, tokenAmountIn: BigNumberish, minPoolAmountOut: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        joinswapPoolAmountOut(tokenIn: string, poolAmountOut: BigNumberish, maxAmountIn: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        name(overrides?: CallOverrides): Promise<string>;
        rebind(token: string, balance: BigNumberish, denorm: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setController(manager: string, overrides?: CallOverrides): Promise<void>;
        setPublicSwap(public_: boolean, overrides?: CallOverrides): Promise<void>;
        setSwapFee(swapFee: BigNumberish, overrides?: CallOverrides): Promise<void>;
        swapExactAmountIn(tokenIn: string, tokenAmountIn: BigNumberish, tokenOut: string, minAmountOut: BigNumberish, maxPrice: BigNumberish, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            tokenAmountOut: BigNumber;
            spotPriceAfter: BigNumber;
        }>;
        swapExactAmountOut(tokenIn: string, maxAmountIn: BigNumberish, tokenOut: string, tokenAmountOut: BigNumberish, maxPrice: BigNumberish, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            tokenAmountIn: BigNumber;
            spotPriceAfter: BigNumber;
        }>;
        symbol(overrides?: CallOverrides): Promise<string>;
        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        transfer(dst: string, amt: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        transferFrom(src: string, dst: string, amt: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        unbind(token: string, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "Approval(address,address,uint256)"(src?: string | null, dst?: string | null, amt?: null): ApprovalEventFilter;
        Approval(src?: string | null, dst?: string | null, amt?: null): ApprovalEventFilter;
        "LOG_CALL(bytes4,address,bytes)"(sig?: BytesLike | null, caller?: string | null, data?: null): LOG_CALLEventFilter;
        LOG_CALL(sig?: BytesLike | null, caller?: string | null, data?: null): LOG_CALLEventFilter;
        "LOG_EXIT(address,address,uint256)"(caller?: string | null, tokenOut?: string | null, tokenAmountOut?: null): LOG_EXITEventFilter;
        LOG_EXIT(caller?: string | null, tokenOut?: string | null, tokenAmountOut?: null): LOG_EXITEventFilter;
        "LOG_JOIN(address,address,uint256)"(caller?: string | null, tokenIn?: string | null, tokenAmountIn?: null): LOG_JOINEventFilter;
        LOG_JOIN(caller?: string | null, tokenIn?: string | null, tokenAmountIn?: null): LOG_JOINEventFilter;
        "LOG_SWAP(address,address,address,uint256,uint256)"(caller?: string | null, tokenIn?: string | null, tokenOut?: string | null, tokenAmountIn?: null, tokenAmountOut?: null): LOG_SWAPEventFilter;
        LOG_SWAP(caller?: string | null, tokenIn?: string | null, tokenOut?: string | null, tokenAmountIn?: null, tokenAmountOut?: null): LOG_SWAPEventFilter;
        "Transfer(address,address,uint256)"(src?: string | null, dst?: string | null, amt?: null): TransferEventFilter;
        Transfer(src?: string | null, dst?: string | null, amt?: null): TransferEventFilter;
    };
    estimateGas: {
        BONE(overrides?: CallOverrides): Promise<BigNumber>;
        BPOW_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
        EXIT_FEE(overrides?: CallOverrides): Promise<BigNumber>;
        INIT_POOL_SUPPLY(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_BOUND_TOKENS(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_BPOW_BASE(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_FEE(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_IN_RATIO(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_OUT_RATIO(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_TOTAL_WEIGHT(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_WEIGHT(overrides?: CallOverrides): Promise<BigNumber>;
        MIN_BALANCE(overrides?: CallOverrides): Promise<BigNumber>;
        MIN_BOUND_TOKENS(overrides?: CallOverrides): Promise<BigNumber>;
        MIN_BPOW_BASE(overrides?: CallOverrides): Promise<BigNumber>;
        MIN_FEE(overrides?: CallOverrides): Promise<BigNumber>;
        MIN_WEIGHT(overrides?: CallOverrides): Promise<BigNumber>;
        allowance(src: string, dst: string, overrides?: CallOverrides): Promise<BigNumber>;
        approve(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        balanceOf(whom: string, overrides?: CallOverrides): Promise<BigNumber>;
        bind(token: string, balance: BigNumberish, denorm: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        calcInGivenOut(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, tokenAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcOutGivenIn(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, tokenAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcPoolInGivenSingleOut(tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, tokenAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcPoolOutGivenSingleIn(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, tokenAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcSingleInGivenPoolOut(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, poolAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcSingleOutGivenPoolIn(tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, poolAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calcSpotPrice(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        decimals(overrides?: CallOverrides): Promise<BigNumber>;
        decreaseApproval(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        exitPool(poolAmountIn: BigNumberish, minAmountsOut: BigNumberish[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        exitswapExternAmountOut(tokenOut: string, tokenAmountOut: BigNumberish, maxPoolAmountIn: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        exitswapPoolAmountIn(tokenOut: string, poolAmountIn: BigNumberish, minAmountOut: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        finalize(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        getBalance(token: string, overrides?: CallOverrides): Promise<BigNumber>;
        getColor(overrides?: CallOverrides): Promise<BigNumber>;
        getController(overrides?: CallOverrides): Promise<BigNumber>;
        getCurrentTokens(overrides?: CallOverrides): Promise<BigNumber>;
        getDenormalizedWeight(token: string, overrides?: CallOverrides): Promise<BigNumber>;
        getFinalTokens(overrides?: CallOverrides): Promise<BigNumber>;
        getNormalizedWeight(token: string, overrides?: CallOverrides): Promise<BigNumber>;
        getNumTokens(overrides?: CallOverrides): Promise<BigNumber>;
        getSpotPrice(tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<BigNumber>;
        getSpotPriceSansFee(tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<BigNumber>;
        getSwapFee(overrides?: CallOverrides): Promise<BigNumber>;
        getTotalDenormalizedWeight(overrides?: CallOverrides): Promise<BigNumber>;
        gulp(token: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        increaseApproval(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        isBound(t: string, overrides?: CallOverrides): Promise<BigNumber>;
        isFinalized(overrides?: CallOverrides): Promise<BigNumber>;
        isPublicSwap(overrides?: CallOverrides): Promise<BigNumber>;
        joinPool(poolAmountOut: BigNumberish, maxAmountsIn: BigNumberish[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        joinswapExternAmountIn(tokenIn: string, tokenAmountIn: BigNumberish, minPoolAmountOut: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        joinswapPoolAmountOut(tokenIn: string, poolAmountOut: BigNumberish, maxAmountIn: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        name(overrides?: CallOverrides): Promise<BigNumber>;
        rebind(token: string, balance: BigNumberish, denorm: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        setController(manager: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        setPublicSwap(public_: boolean, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        setSwapFee(swapFee: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        swapExactAmountIn(tokenIn: string, tokenAmountIn: BigNumberish, tokenOut: string, minAmountOut: BigNumberish, maxPrice: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        swapExactAmountOut(tokenIn: string, maxAmountIn: BigNumberish, tokenOut: string, tokenAmountOut: BigNumberish, maxPrice: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        symbol(overrides?: CallOverrides): Promise<BigNumber>;
        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        transfer(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        transferFrom(src: string, dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        unbind(token: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        BONE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        BPOW_PRECISION(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        EXIT_FEE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        INIT_POOL_SUPPLY(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_BOUND_TOKENS(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_BPOW_BASE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_FEE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_IN_RATIO(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_OUT_RATIO(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_TOTAL_WEIGHT(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_WEIGHT(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MIN_BALANCE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MIN_BOUND_TOKENS(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MIN_BPOW_BASE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MIN_FEE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MIN_WEIGHT(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        allowance(src: string, dst: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        approve(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        balanceOf(whom: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        bind(token: string, balance: BigNumberish, denorm: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        calcInGivenOut(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, tokenAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcOutGivenIn(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, tokenAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcPoolInGivenSingleOut(tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, tokenAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcPoolOutGivenSingleIn(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, tokenAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcSingleInGivenPoolOut(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, poolAmountOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcSingleOutGivenPoolIn(tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, poolSupply: BigNumberish, totalWeight: BigNumberish, poolAmountIn: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcSpotPrice(tokenBalanceIn: BigNumberish, tokenWeightIn: BigNumberish, tokenBalanceOut: BigNumberish, tokenWeightOut: BigNumberish, swapFee: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        decreaseApproval(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        exitPool(poolAmountIn: BigNumberish, minAmountsOut: BigNumberish[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        exitswapExternAmountOut(tokenOut: string, tokenAmountOut: BigNumberish, maxPoolAmountIn: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        exitswapPoolAmountIn(tokenOut: string, poolAmountIn: BigNumberish, minAmountOut: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        finalize(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        getBalance(token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getColor(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getController(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getCurrentTokens(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getDenormalizedWeight(token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getFinalTokens(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getNormalizedWeight(token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getNumTokens(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getSpotPrice(tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getSpotPriceSansFee(tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getSwapFee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getTotalDenormalizedWeight(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        gulp(token: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        increaseApproval(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        isBound(t: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isFinalized(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isPublicSwap(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        joinPool(poolAmountOut: BigNumberish, maxAmountsIn: BigNumberish[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        joinswapExternAmountIn(tokenIn: string, tokenAmountIn: BigNumberish, minPoolAmountOut: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        joinswapPoolAmountOut(tokenIn: string, poolAmountOut: BigNumberish, maxAmountIn: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rebind(token: string, balance: BigNumberish, denorm: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        setController(manager: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        setPublicSwap(public_: boolean, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        setSwapFee(swapFee: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        swapExactAmountIn(tokenIn: string, tokenAmountIn: BigNumberish, tokenOut: string, minAmountOut: BigNumberish, maxPrice: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        swapExactAmountOut(tokenIn: string, maxAmountIn: BigNumberish, tokenOut: string, tokenAmountOut: BigNumberish, maxPrice: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transfer(dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        transferFrom(src: string, dst: string, amt: BigNumberish, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        unbind(token: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
    };
}
//# sourceMappingURL=BPool.d.ts.map