@cryptoalgebra/alm-sdk/dist/src/abis/types/AlgebraVault.d.ts

Algebra ALM SDK

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, PromiseOrValue } from "./common";
export interface AlgebraVaultInterface extends utils.Interface {
    functions: {
        "PRECISION()": FunctionFragment;
        "affiliate()": FunctionFragment;
        "algebraSwapCallback(int256,int256,bytes)": FunctionFragment;
        "algebraVaultFactory()": FunctionFragment;
        "allowToken0()": FunctionFragment;
        "allowToken1()": FunctionFragment;
        "allowance(address,address)": FunctionFragment;
        "ammFeeRecipient()": FunctionFragment;
        "approve(address,uint256)": FunctionFragment;
        "auxTwapPeriod()": FunctionFragment;
        "balanceOf(address)": FunctionFragment;
        "baseLower()": FunctionFragment;
        "basePositionId()": FunctionFragment;
        "baseUpper()": FunctionFragment;
        "collectFees()": FunctionFragment;
        "currentTick()": FunctionFragment;
        "decimals()": FunctionFragment;
        "decreaseAllowance(address,uint256)": FunctionFragment;
        "deposit(uint256,uint256,address)": FunctionFragment;
        "deposit0Max()": FunctionFragment;
        "deposit1Max()": FunctionFragment;
        "fee()": FunctionFragment;
        "getBasePosition()": FunctionFragment;
        "getLimitPosition()": FunctionFragment;
        "getTotalAmounts()": FunctionFragment;
        "hysteresis()": FunctionFragment;
        "increaseAllowance(address,uint256)": FunctionFragment;
        "limitLower()": FunctionFragment;
        "limitPositionId()": FunctionFragment;
        "limitUpper()": FunctionFragment;
        "name()": FunctionFragment;
        "owner()": FunctionFragment;
        "pool()": FunctionFragment;
        "rebalance(int24,int24,int24,int24,int256)": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "resetAllowances()": FunctionFragment;
        "setAffiliate(address)": FunctionFragment;
        "setAmmFeeRecipient(address)": FunctionFragment;
        "setAuxTwapPeriod(uint32)": FunctionFragment;
        "setDepositMax(uint256,uint256)": FunctionFragment;
        "setHysteresis(uint256)": FunctionFragment;
        "setTwapPeriod(uint32)": FunctionFragment;
        "symbol()": FunctionFragment;
        "tickSpacing()": FunctionFragment;
        "token0()": FunctionFragment;
        "token1()": FunctionFragment;
        "totalSupply()": FunctionFragment;
        "transfer(address,uint256)": FunctionFragment;
        "transferFrom(address,address,uint256)": FunctionFragment;
        "transferOwnership(address)": FunctionFragment;
        "twapPeriod()": FunctionFragment;
        "withdraw(uint256,address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "PRECISION" | "affiliate" | "algebraSwapCallback" | "algebraVaultFactory" | "allowToken0" | "allowToken1" | "allowance" | "ammFeeRecipient" | "approve" | "auxTwapPeriod" | "balanceOf" | "baseLower" | "basePositionId" | "baseUpper" | "collectFees" | "currentTick" | "decimals" | "decreaseAllowance" | "deposit" | "deposit0Max" | "deposit1Max" | "fee" | "getBasePosition" | "getLimitPosition" | "getTotalAmounts" | "hysteresis" | "increaseAllowance" | "limitLower" | "limitPositionId" | "limitUpper" | "name" | "owner" | "pool" | "rebalance" | "renounceOwnership" | "resetAllowances" | "setAffiliate" | "setAmmFeeRecipient" | "setAuxTwapPeriod" | "setDepositMax" | "setHysteresis" | "setTwapPeriod" | "symbol" | "tickSpacing" | "token0" | "token1" | "totalSupply" | "transfer" | "transferFrom" | "transferOwnership" | "twapPeriod" | "withdraw"): FunctionFragment;
    encodeFunctionData(functionFragment: "PRECISION", values?: undefined): string;
    encodeFunctionData(functionFragment: "affiliate", values?: undefined): string;
    encodeFunctionData(functionFragment: "algebraSwapCallback", values: [
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BytesLike>
    ]): string;
    encodeFunctionData(functionFragment: "algebraVaultFactory", values?: undefined): string;
    encodeFunctionData(functionFragment: "allowToken0", values?: undefined): string;
    encodeFunctionData(functionFragment: "allowToken1", values?: undefined): string;
    encodeFunctionData(functionFragment: "allowance", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "ammFeeRecipient", values?: undefined): string;
    encodeFunctionData(functionFragment: "approve", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "auxTwapPeriod", values?: undefined): string;
    encodeFunctionData(functionFragment: "balanceOf", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "baseLower", values?: undefined): string;
    encodeFunctionData(functionFragment: "basePositionId", values?: undefined): string;
    encodeFunctionData(functionFragment: "baseUpper", values?: undefined): string;
    encodeFunctionData(functionFragment: "collectFees", values?: undefined): string;
    encodeFunctionData(functionFragment: "currentTick", values?: undefined): string;
    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
    encodeFunctionData(functionFragment: "decreaseAllowance", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "deposit", values: [
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>
    ]): string;
    encodeFunctionData(functionFragment: "deposit0Max", values?: undefined): string;
    encodeFunctionData(functionFragment: "deposit1Max", values?: undefined): string;
    encodeFunctionData(functionFragment: "fee", values?: undefined): string;
    encodeFunctionData(functionFragment: "getBasePosition", values?: undefined): string;
    encodeFunctionData(functionFragment: "getLimitPosition", values?: undefined): string;
    encodeFunctionData(functionFragment: "getTotalAmounts", values?: undefined): string;
    encodeFunctionData(functionFragment: "hysteresis", values?: undefined): string;
    encodeFunctionData(functionFragment: "increaseAllowance", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "limitLower", values?: undefined): string;
    encodeFunctionData(functionFragment: "limitPositionId", values?: undefined): string;
    encodeFunctionData(functionFragment: "limitUpper", values?: undefined): string;
    encodeFunctionData(functionFragment: "name", values?: undefined): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "pool", values?: undefined): string;
    encodeFunctionData(functionFragment: "rebalance", values: [
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "resetAllowances", values?: undefined): string;
    encodeFunctionData(functionFragment: "setAffiliate", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setAmmFeeRecipient", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setAuxTwapPeriod", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setDepositMax", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setHysteresis", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setTwapPeriod", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
    encodeFunctionData(functionFragment: "tickSpacing", values?: undefined): string;
    encodeFunctionData(functionFragment: "token0", values?: undefined): string;
    encodeFunctionData(functionFragment: "token1", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
    encodeFunctionData(functionFragment: "transfer", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "transferFrom", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "twapPeriod", values?: undefined): string;
    encodeFunctionData(functionFragment: "withdraw", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    decodeFunctionResult(functionFragment: "PRECISION", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "affiliate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "algebraSwapCallback", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "algebraVaultFactory", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "allowToken0", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "allowToken1", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "ammFeeRecipient", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "auxTwapPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "baseLower", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "basePositionId", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "baseUpper", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "collectFees", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "currentTick", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "deposit0Max", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "deposit1Max", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "fee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getBasePosition", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getLimitPosition", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getTotalAmounts", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "hysteresis", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "limitLower", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "limitPositionId", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "limitUpper", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rebalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "resetAllowances", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setAffiliate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setAmmFeeRecipient", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setAuxTwapPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDepositMax", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setHysteresis", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setTwapPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "tickSpacing", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "token0", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "token1", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "twapPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
    events: {
        "Affiliate(address,address)": EventFragment;
        "AmmFeeRecipient(address,address)": EventFragment;
        "Approval(address,address,uint256)": EventFragment;
        "CollectFees(address,uint256,uint256)": EventFragment;
        "DeployAlgebraVault(address,address,bool,bool,address,uint256)": EventFragment;
        "Deposit(address,address,uint256,uint256,uint256)": EventFragment;
        "DepositMax(address,uint256,uint256)": EventFragment;
        "Hysteresis(address,uint256)": EventFragment;
        "OwnershipTransferred(address,address)": EventFragment;
        "Rebalance(int24,uint256,uint256,uint256,uint256,uint256)": EventFragment;
        "SetAuxTwapPeriod(address,uint32)": EventFragment;
        "SetTwapPeriod(address,uint32)": EventFragment;
        "Transfer(address,address,uint256)": EventFragment;
        "Withdraw(address,address,uint256,uint256,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Affiliate"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "AmmFeeRecipient"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "CollectFees"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "DeployAlgebraVault"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "DepositMax"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Hysteresis"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Rebalance"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetAuxTwapPeriod"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetTwapPeriod"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
}
export interface AffiliateEventObject {
    sender: string;
    affiliate: string;
}
export type AffiliateEvent = TypedEvent<[string, string], AffiliateEventObject>;
export type AffiliateEventFilter = TypedEventFilter<AffiliateEvent>;
export interface AmmFeeRecipientEventObject {
    sender: string;
    ammFeeRecipient: string;
}
export type AmmFeeRecipientEvent = TypedEvent<[
    string,
    string
], AmmFeeRecipientEventObject>;
export type AmmFeeRecipientEventFilter = TypedEventFilter<AmmFeeRecipientEvent>;
export interface ApprovalEventObject {
    owner: string;
    spender: string;
    value: BigNumber;
}
export type ApprovalEvent = TypedEvent<[
    string,
    string,
    BigNumber
], ApprovalEventObject>;
export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
export interface CollectFeesEventObject {
    sender: string;
    feeAmount0: BigNumber;
    feeAmount1: BigNumber;
}
export type CollectFeesEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], CollectFeesEventObject>;
export type CollectFeesEventFilter = TypedEventFilter<CollectFeesEvent>;
export interface DeployAlgebraVaultEventObject {
    sender: string;
    pool: string;
    allowToken0: boolean;
    allowToken1: boolean;
    owner: string;
    twapPeriod: BigNumber;
}
export type DeployAlgebraVaultEvent = TypedEvent<[
    string,
    string,
    boolean,
    boolean,
    string,
    BigNumber
], DeployAlgebraVaultEventObject>;
export type DeployAlgebraVaultEventFilter = TypedEventFilter<DeployAlgebraVaultEvent>;
export interface DepositEventObject {
    sender: string;
    to: string;
    shares: BigNumber;
    amount0: BigNumber;
    amount1: BigNumber;
}
export type DepositEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber,
    BigNumber
], DepositEventObject>;
export type DepositEventFilter = TypedEventFilter<DepositEvent>;
export interface DepositMaxEventObject {
    sender: string;
    deposit0Max: BigNumber;
    deposit1Max: BigNumber;
}
export type DepositMaxEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], DepositMaxEventObject>;
export type DepositMaxEventFilter = TypedEventFilter<DepositMaxEvent>;
export interface HysteresisEventObject {
    sender: string;
    hysteresis: BigNumber;
}
export type HysteresisEvent = TypedEvent<[
    string,
    BigNumber
], HysteresisEventObject>;
export type HysteresisEventFilter = TypedEventFilter<HysteresisEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface RebalanceEventObject {
    tick: number;
    totalAmount0: BigNumber;
    totalAmount1: BigNumber;
    feeAmount0: BigNumber;
    feeAmount1: BigNumber;
    totalSupply: BigNumber;
}
export type RebalanceEvent = TypedEvent<[
    number,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], RebalanceEventObject>;
export type RebalanceEventFilter = TypedEventFilter<RebalanceEvent>;
export interface SetAuxTwapPeriodEventObject {
    sender: string;
    newAuxTwapPeriod: number;
}
export type SetAuxTwapPeriodEvent = TypedEvent<[
    string,
    number
], SetAuxTwapPeriodEventObject>;
export type SetAuxTwapPeriodEventFilter = TypedEventFilter<SetAuxTwapPeriodEvent>;
export interface SetTwapPeriodEventObject {
    sender: string;
    newTwapPeriod: number;
}
export type SetTwapPeriodEvent = TypedEvent<[
    string,
    number
], SetTwapPeriodEventObject>;
export type SetTwapPeriodEventFilter = TypedEventFilter<SetTwapPeriodEvent>;
export interface TransferEventObject {
    from: string;
    to: string;
    value: BigNumber;
}
export type TransferEvent = TypedEvent<[
    string,
    string,
    BigNumber
], TransferEventObject>;
export type TransferEventFilter = TypedEventFilter<TransferEvent>;
export interface WithdrawEventObject {
    sender: string;
    to: string;
    shares: BigNumber;
    amount0: BigNumber;
    amount1: BigNumber;
}
export type WithdrawEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber,
    BigNumber
], WithdrawEventObject>;
export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
export interface AlgebraVault extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: AlgebraVaultInterface;
    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: {
        PRECISION(overrides?: CallOverrides): Promise<[BigNumber]>;
        affiliate(overrides?: CallOverrides): Promise<[string]>;
        algebraSwapCallback(amount0Delta: PromiseOrValue<BigNumberish>, amount1Delta: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        algebraVaultFactory(overrides?: CallOverrides): Promise<[string]>;
        allowToken0(overrides?: CallOverrides): Promise<[boolean]>;
        allowToken1(overrides?: CallOverrides): Promise<[boolean]>;
        allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        ammFeeRecipient(overrides?: CallOverrides): Promise<[string]>;
        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        auxTwapPeriod(overrides?: CallOverrides): Promise<[number]>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        baseLower(overrides?: CallOverrides): Promise<[number]>;
        basePositionId(overrides?: CallOverrides): Promise<[BigNumber]>;
        baseUpper(overrides?: CallOverrides): Promise<[number]>;
        collectFees(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        currentTick(overrides?: CallOverrides): Promise<[number] & {
            tick: number;
        }>;
        decimals(overrides?: CallOverrides): Promise<[number]>;
        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        deposit(deposit0: PromiseOrValue<BigNumberish>, deposit1: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        deposit0Max(overrides?: CallOverrides): Promise<[BigNumber]>;
        deposit1Max(overrides?: CallOverrides): Promise<[BigNumber]>;
        fee(overrides?: CallOverrides): Promise<[number] & {
            fee_: number;
        }>;
        getBasePosition(overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            liquidity: BigNumber;
            amount0: BigNumber;
            amount1: BigNumber;
        }>;
        getLimitPosition(overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            liquidity: BigNumber;
            amount0: BigNumber;
            amount1: BigNumber;
        }>;
        getTotalAmounts(overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            total0: BigNumber;
            total1: BigNumber;
        }>;
        hysteresis(overrides?: CallOverrides): Promise<[BigNumber]>;
        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        limitLower(overrides?: CallOverrides): Promise<[number]>;
        limitPositionId(overrides?: CallOverrides): Promise<[BigNumber]>;
        limitUpper(overrides?: CallOverrides): Promise<[number]>;
        name(overrides?: CallOverrides): Promise<[string]>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        pool(overrides?: CallOverrides): Promise<[string]>;
        rebalance(_baseLower: PromiseOrValue<BigNumberish>, _baseUpper: PromiseOrValue<BigNumberish>, _limitLower: PromiseOrValue<BigNumberish>, _limitUpper: PromiseOrValue<BigNumberish>, swapQuantity: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        resetAllowances(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setAffiliate(_affiliate: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setAmmFeeRecipient(_ammFeeRecipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setAuxTwapPeriod(newAuxTwapPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setDepositMax(_deposit0Max: PromiseOrValue<BigNumberish>, _deposit1Max: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setHysteresis(_hysteresis: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setTwapPeriod(newTwapPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        symbol(overrides?: CallOverrides): Promise<[string]>;
        tickSpacing(overrides?: CallOverrides): Promise<[number]>;
        token0(overrides?: CallOverrides): Promise<[string]>;
        token1(overrides?: CallOverrides): Promise<[string]>;
        totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
        transfer(to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        twapPeriod(overrides?: CallOverrides): Promise<[number]>;
        withdraw(shares: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
    };
    PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
    affiliate(overrides?: CallOverrides): Promise<string>;
    algebraSwapCallback(amount0Delta: PromiseOrValue<BigNumberish>, amount1Delta: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    algebraVaultFactory(overrides?: CallOverrides): Promise<string>;
    allowToken0(overrides?: CallOverrides): Promise<boolean>;
    allowToken1(overrides?: CallOverrides): Promise<boolean>;
    allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    ammFeeRecipient(overrides?: CallOverrides): Promise<string>;
    approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    auxTwapPeriod(overrides?: CallOverrides): Promise<number>;
    balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    baseLower(overrides?: CallOverrides): Promise<number>;
    basePositionId(overrides?: CallOverrides): Promise<BigNumber>;
    baseUpper(overrides?: CallOverrides): Promise<number>;
    collectFees(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    currentTick(overrides?: CallOverrides): Promise<number>;
    decimals(overrides?: CallOverrides): Promise<number>;
    decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    deposit(deposit0: PromiseOrValue<BigNumberish>, deposit1: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    deposit0Max(overrides?: CallOverrides): Promise<BigNumber>;
    deposit1Max(overrides?: CallOverrides): Promise<BigNumber>;
    fee(overrides?: CallOverrides): Promise<number>;
    getBasePosition(overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        liquidity: BigNumber;
        amount0: BigNumber;
        amount1: BigNumber;
    }>;
    getLimitPosition(overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        liquidity: BigNumber;
        amount0: BigNumber;
        amount1: BigNumber;
    }>;
    getTotalAmounts(overrides?: CallOverrides): Promise<[BigNumber, BigNumber] & {
        total0: BigNumber;
        total1: BigNumber;
    }>;
    hysteresis(overrides?: CallOverrides): Promise<BigNumber>;
    increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    limitLower(overrides?: CallOverrides): Promise<number>;
    limitPositionId(overrides?: CallOverrides): Promise<BigNumber>;
    limitUpper(overrides?: CallOverrides): Promise<number>;
    name(overrides?: CallOverrides): Promise<string>;
    owner(overrides?: CallOverrides): Promise<string>;
    pool(overrides?: CallOverrides): Promise<string>;
    rebalance(_baseLower: PromiseOrValue<BigNumberish>, _baseUpper: PromiseOrValue<BigNumberish>, _limitLower: PromiseOrValue<BigNumberish>, _limitUpper: PromiseOrValue<BigNumberish>, swapQuantity: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    renounceOwnership(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    resetAllowances(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setAffiliate(_affiliate: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setAmmFeeRecipient(_ammFeeRecipient: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setAuxTwapPeriod(newAuxTwapPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setDepositMax(_deposit0Max: PromiseOrValue<BigNumberish>, _deposit1Max: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setHysteresis(_hysteresis: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setTwapPeriod(newTwapPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    symbol(overrides?: CallOverrides): Promise<string>;
    tickSpacing(overrides?: CallOverrides): Promise<number>;
    token0(overrides?: CallOverrides): Promise<string>;
    token1(overrides?: CallOverrides): Promise<string>;
    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
    transfer(to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    twapPeriod(overrides?: CallOverrides): Promise<number>;
    withdraw(shares: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
        affiliate(overrides?: CallOverrides): Promise<string>;
        algebraSwapCallback(amount0Delta: PromiseOrValue<BigNumberish>, amount1Delta: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        algebraVaultFactory(overrides?: CallOverrides): Promise<string>;
        allowToken0(overrides?: CallOverrides): Promise<boolean>;
        allowToken1(overrides?: CallOverrides): Promise<boolean>;
        allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        ammFeeRecipient(overrides?: CallOverrides): Promise<string>;
        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        auxTwapPeriod(overrides?: CallOverrides): Promise<number>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        baseLower(overrides?: CallOverrides): Promise<number>;
        basePositionId(overrides?: CallOverrides): Promise<BigNumber>;
        baseUpper(overrides?: CallOverrides): Promise<number>;
        collectFees(overrides?: CallOverrides): Promise<[BigNumber, BigNumber] & {
            fees0: BigNumber;
            fees1: BigNumber;
        }>;
        currentTick(overrides?: CallOverrides): Promise<number>;
        decimals(overrides?: CallOverrides): Promise<number>;
        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        deposit(deposit0: PromiseOrValue<BigNumberish>, deposit1: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        deposit0Max(overrides?: CallOverrides): Promise<BigNumber>;
        deposit1Max(overrides?: CallOverrides): Promise<BigNumber>;
        fee(overrides?: CallOverrides): Promise<number>;
        getBasePosition(overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            liquidity: BigNumber;
            amount0: BigNumber;
            amount1: BigNumber;
        }>;
        getLimitPosition(overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            liquidity: BigNumber;
            amount0: BigNumber;
            amount1: BigNumber;
        }>;
        getTotalAmounts(overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            total0: BigNumber;
            total1: BigNumber;
        }>;
        hysteresis(overrides?: CallOverrides): Promise<BigNumber>;
        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        limitLower(overrides?: CallOverrides): Promise<number>;
        limitPositionId(overrides?: CallOverrides): Promise<BigNumber>;
        limitUpper(overrides?: CallOverrides): Promise<number>;
        name(overrides?: CallOverrides): Promise<string>;
        owner(overrides?: CallOverrides): Promise<string>;
        pool(overrides?: CallOverrides): Promise<string>;
        rebalance(_baseLower: PromiseOrValue<BigNumberish>, _baseUpper: PromiseOrValue<BigNumberish>, _limitLower: PromiseOrValue<BigNumberish>, _limitUpper: PromiseOrValue<BigNumberish>, swapQuantity: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        resetAllowances(overrides?: CallOverrides): Promise<void>;
        setAffiliate(_affiliate: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setAmmFeeRecipient(_ammFeeRecipient: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setAuxTwapPeriod(newAuxTwapPeriod: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setDepositMax(_deposit0Max: PromiseOrValue<BigNumberish>, _deposit1Max: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setHysteresis(_hysteresis: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setTwapPeriod(newTwapPeriod: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        symbol(overrides?: CallOverrides): Promise<string>;
        tickSpacing(overrides?: CallOverrides): Promise<number>;
        token0(overrides?: CallOverrides): Promise<string>;
        token1(overrides?: CallOverrides): Promise<string>;
        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        transfer(to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        twapPeriod(overrides?: CallOverrides): Promise<number>;
        withdraw(shares: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            amount0: BigNumber;
            amount1: BigNumber;
        }>;
    };
    filters: {
        "Affiliate(address,address)"(sender?: PromiseOrValue<string> | null, affiliate?: null): AffiliateEventFilter;
        Affiliate(sender?: PromiseOrValue<string> | null, affiliate?: null): AffiliateEventFilter;
        "AmmFeeRecipient(address,address)"(sender?: PromiseOrValue<string> | null, ammFeeRecipient?: null): AmmFeeRecipientEventFilter;
        AmmFeeRecipient(sender?: PromiseOrValue<string> | null, ammFeeRecipient?: null): AmmFeeRecipientEventFilter;
        "Approval(address,address,uint256)"(owner?: PromiseOrValue<string> | null, spender?: PromiseOrValue<string> | null, value?: null): ApprovalEventFilter;
        Approval(owner?: PromiseOrValue<string> | null, spender?: PromiseOrValue<string> | null, value?: null): ApprovalEventFilter;
        "CollectFees(address,uint256,uint256)"(sender?: PromiseOrValue<string> | null, feeAmount0?: null, feeAmount1?: null): CollectFeesEventFilter;
        CollectFees(sender?: PromiseOrValue<string> | null, feeAmount0?: null, feeAmount1?: null): CollectFeesEventFilter;
        "DeployAlgebraVault(address,address,bool,bool,address,uint256)"(sender?: PromiseOrValue<string> | null, pool?: PromiseOrValue<string> | null, allowToken0?: null, allowToken1?: null, owner?: null, twapPeriod?: null): DeployAlgebraVaultEventFilter;
        DeployAlgebraVault(sender?: PromiseOrValue<string> | null, pool?: PromiseOrValue<string> | null, allowToken0?: null, allowToken1?: null, owner?: null, twapPeriod?: null): DeployAlgebraVaultEventFilter;
        "Deposit(address,address,uint256,uint256,uint256)"(sender?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, shares?: null, amount0?: null, amount1?: null): DepositEventFilter;
        Deposit(sender?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, shares?: null, amount0?: null, amount1?: null): DepositEventFilter;
        "DepositMax(address,uint256,uint256)"(sender?: PromiseOrValue<string> | null, deposit0Max?: null, deposit1Max?: null): DepositMaxEventFilter;
        DepositMax(sender?: PromiseOrValue<string> | null, deposit0Max?: null, deposit1Max?: null): DepositMaxEventFilter;
        "Hysteresis(address,uint256)"(sender?: PromiseOrValue<string> | null, hysteresis?: null): HysteresisEventFilter;
        Hysteresis(sender?: PromiseOrValue<string> | null, hysteresis?: null): HysteresisEventFilter;
        "OwnershipTransferred(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
        "Rebalance(int24,uint256,uint256,uint256,uint256,uint256)"(tick?: null, totalAmount0?: null, totalAmount1?: null, feeAmount0?: null, feeAmount1?: null, totalSupply?: null): RebalanceEventFilter;
        Rebalance(tick?: null, totalAmount0?: null, totalAmount1?: null, feeAmount0?: null, feeAmount1?: null, totalSupply?: null): RebalanceEventFilter;
        "SetAuxTwapPeriod(address,uint32)"(sender?: null, newAuxTwapPeriod?: null): SetAuxTwapPeriodEventFilter;
        SetAuxTwapPeriod(sender?: null, newAuxTwapPeriod?: null): SetAuxTwapPeriodEventFilter;
        "SetTwapPeriod(address,uint32)"(sender?: null, newTwapPeriod?: null): SetTwapPeriodEventFilter;
        SetTwapPeriod(sender?: null, newTwapPeriod?: null): SetTwapPeriodEventFilter;
        "Transfer(address,address,uint256)"(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, value?: null): TransferEventFilter;
        Transfer(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, value?: null): TransferEventFilter;
        "Withdraw(address,address,uint256,uint256,uint256)"(sender?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, shares?: null, amount0?: null, amount1?: null): WithdrawEventFilter;
        Withdraw(sender?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, shares?: null, amount0?: null, amount1?: null): WithdrawEventFilter;
    };
    estimateGas: {
        PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
        affiliate(overrides?: CallOverrides): Promise<BigNumber>;
        algebraSwapCallback(amount0Delta: PromiseOrValue<BigNumberish>, amount1Delta: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        algebraVaultFactory(overrides?: CallOverrides): Promise<BigNumber>;
        allowToken0(overrides?: CallOverrides): Promise<BigNumber>;
        allowToken1(overrides?: CallOverrides): Promise<BigNumber>;
        allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        ammFeeRecipient(overrides?: CallOverrides): Promise<BigNumber>;
        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        auxTwapPeriod(overrides?: CallOverrides): Promise<BigNumber>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        baseLower(overrides?: CallOverrides): Promise<BigNumber>;
        basePositionId(overrides?: CallOverrides): Promise<BigNumber>;
        baseUpper(overrides?: CallOverrides): Promise<BigNumber>;
        collectFees(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        currentTick(overrides?: CallOverrides): Promise<BigNumber>;
        decimals(overrides?: CallOverrides): Promise<BigNumber>;
        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        deposit(deposit0: PromiseOrValue<BigNumberish>, deposit1: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        deposit0Max(overrides?: CallOverrides): Promise<BigNumber>;
        deposit1Max(overrides?: CallOverrides): Promise<BigNumber>;
        fee(overrides?: CallOverrides): Promise<BigNumber>;
        getBasePosition(overrides?: CallOverrides): Promise<BigNumber>;
        getLimitPosition(overrides?: CallOverrides): Promise<BigNumber>;
        getTotalAmounts(overrides?: CallOverrides): Promise<BigNumber>;
        hysteresis(overrides?: CallOverrides): Promise<BigNumber>;
        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        limitLower(overrides?: CallOverrides): Promise<BigNumber>;
        limitPositionId(overrides?: CallOverrides): Promise<BigNumber>;
        limitUpper(overrides?: CallOverrides): Promise<BigNumber>;
        name(overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        pool(overrides?: CallOverrides): Promise<BigNumber>;
        rebalance(_baseLower: PromiseOrValue<BigNumberish>, _baseUpper: PromiseOrValue<BigNumberish>, _limitLower: PromiseOrValue<BigNumberish>, _limitUpper: PromiseOrValue<BigNumberish>, swapQuantity: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        resetAllowances(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setAffiliate(_affiliate: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setAmmFeeRecipient(_ammFeeRecipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setAuxTwapPeriod(newAuxTwapPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setDepositMax(_deposit0Max: PromiseOrValue<BigNumberish>, _deposit1Max: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setHysteresis(_hysteresis: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setTwapPeriod(newTwapPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        symbol(overrides?: CallOverrides): Promise<BigNumber>;
        tickSpacing(overrides?: CallOverrides): Promise<BigNumber>;
        token0(overrides?: CallOverrides): Promise<BigNumber>;
        token1(overrides?: CallOverrides): Promise<BigNumber>;
        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        transfer(to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        twapPeriod(overrides?: CallOverrides): Promise<BigNumber>;
        withdraw(shares: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        PRECISION(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        affiliate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        algebraSwapCallback(amount0Delta: PromiseOrValue<BigNumberish>, amount1Delta: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        algebraVaultFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        allowToken0(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        allowToken1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        ammFeeRecipient(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;