import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, 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 declare namespace ITwapStrategyBase {
    type TickStruct = {
        tickLower: PromiseOrValue<BigNumberish>;
        tickUpper: PromiseOrValue<BigNumberish>;
    };
    type TickStructOutput = [number, number] & {
        tickLower: number;
        tickUpper: number;
    };
}
export declare namespace ITwapStrategyFactory {
    type CreateStrategyParamsStruct = {
        operator: PromiseOrValue<string>;
        feeTo: PromiseOrValue<string>;
        managementFeeRate: PromiseOrValue<BigNumberish>;
        performanceFeeRate: PromiseOrValue<BigNumberish>;
        limit: PromiseOrValue<BigNumberish>;
        pool: PromiseOrValue<string>;
        useTwap: [PromiseOrValue<boolean>, PromiseOrValue<boolean>];
        ticks: ITwapStrategyBase.TickStruct[];
    };
    type CreateStrategyParamsStructOutput = [
        string,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        [
            boolean,
            boolean
        ],
        ITwapStrategyBase.TickStructOutput[]
    ] & {
        operator: string;
        feeTo: string;
        managementFeeRate: BigNumber;
        performanceFeeRate: BigNumber;
        limit: BigNumber;
        pool: string;
        useTwap: [boolean, boolean];
        ticks: ITwapStrategyBase.TickStructOutput[];
    };
}
export interface DefiedgeTwapFactoryInterface extends utils.Interface {
    functions: {
        "MAX_DECIMAL()": FunctionFragment;
        "MAX_PROTOCOL_PERFORMANCE_FEES_RATE()": FunctionFragment;
        "acceptGovernance()": FunctionFragment;
        "algebraFactory()": FunctionFragment;
        "allowedSlippage(address)": FunctionFragment;
        "allowedSwapDeviation(address)": FunctionFragment;
        "chainlinkRegistry()": FunctionFragment;
        "changeAllowedSlippage(address,uint256)": FunctionFragment;
        "changeAllowedSwapDeviation(address,uint256)": FunctionFragment;
        "changeDefaultTwapPeriod(address,uint256)": FunctionFragment;
        "changeDefaultValues(uint256,uint256)": FunctionFragment;
        "changeFeeForStrategyCreation(uint256)": FunctionFragment;
        "changeFeeTo(address)": FunctionFragment;
        "changeGovernance(address)": FunctionFragment;
        "changeProtocolFeeRate(uint256)": FunctionFragment;
        "changeProtocolPerformanceFeeRate(address,address,uint256)": FunctionFragment;
        "changeSwapProxy(address)": FunctionFragment;
        "claimFees(address)": FunctionFragment;
        "createStrategy((address,address,uint256,uint256,uint256,address,bool[2],(int24,int24)[]))": FunctionFragment;
        "defaultAllowedSlippage()": FunctionFragment;
        "defaultAllowedSwapDeviation()": FunctionFragment;
        "defaultProtocolPerformanceFeeRate()": FunctionFragment;
        "defaultTwapPricePeriod()": FunctionFragment;
        "denied(address)": FunctionFragment;
        "deny(address,bool)": FunctionFragment;
        "deployerProxy()": FunctionFragment;
        "feeTo()": FunctionFragment;
        "freezeEmergency()": FunctionFragment;
        "freezeEmergencyFunctions()": FunctionFragment;
        "getHeartBeat(address,address)": FunctionFragment;
        "getProtocolPerformanceFeeRate(address,address)": FunctionFragment;
        "governance()": FunctionFragment;
        "isValidStrategy(address)": FunctionFragment;
        "pendingGovernance()": FunctionFragment;
        "protocolFeeRate()": FunctionFragment;
        "protocolPerformanceFeeRateByPool(address)": FunctionFragment;
        "protocolPerformanceFeeRateByStrategy(address)": FunctionFragment;
        "setMinHeartbeat(address,address,uint256)": FunctionFragment;
        "strategyByIndex(uint256)": FunctionFragment;
        "strategyByManager(address)": FunctionFragment;
        "strategyCreationFee()": FunctionFragment;
        "swapProxy()": FunctionFragment;
        "totalIndex()": FunctionFragment;
        "twapPricePeriod(address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "MAX_DECIMAL" | "MAX_PROTOCOL_PERFORMANCE_FEES_RATE" | "acceptGovernance" | "algebraFactory" | "allowedSlippage" | "allowedSwapDeviation" | "chainlinkRegistry" | "changeAllowedSlippage" | "changeAllowedSwapDeviation" | "changeDefaultTwapPeriod" | "changeDefaultValues" | "changeFeeForStrategyCreation" | "changeFeeTo" | "changeGovernance" | "changeProtocolFeeRate" | "changeProtocolPerformanceFeeRate" | "changeSwapProxy" | "claimFees" | "createStrategy" | "defaultAllowedSlippage" | "defaultAllowedSwapDeviation" | "defaultProtocolPerformanceFeeRate" | "defaultTwapPricePeriod" | "denied" | "deny" | "deployerProxy" | "feeTo" | "freezeEmergency" | "freezeEmergencyFunctions" | "getHeartBeat" | "getProtocolPerformanceFeeRate" | "governance" | "isValidStrategy" | "pendingGovernance" | "protocolFeeRate" | "protocolPerformanceFeeRateByPool" | "protocolPerformanceFeeRateByStrategy" | "setMinHeartbeat" | "strategyByIndex" | "strategyByManager" | "strategyCreationFee" | "swapProxy" | "totalIndex" | "twapPricePeriod"): FunctionFragment;
    encodeFunctionData(functionFragment: "MAX_DECIMAL", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_PROTOCOL_PERFORMANCE_FEES_RATE", values?: undefined): string;
    encodeFunctionData(functionFragment: "acceptGovernance", values?: undefined): string;
    encodeFunctionData(functionFragment: "algebraFactory", values?: undefined): string;
    encodeFunctionData(functionFragment: "allowedSlippage", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "allowedSwapDeviation", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "chainlinkRegistry", values?: undefined): string;
    encodeFunctionData(functionFragment: "changeAllowedSlippage", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "changeAllowedSwapDeviation", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "changeDefaultTwapPeriod", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "changeDefaultValues", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "changeFeeForStrategyCreation", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "changeFeeTo", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "changeGovernance", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "changeProtocolFeeRate", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "changeProtocolPerformanceFeeRate", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "changeSwapProxy", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "claimFees", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "createStrategy", values: [ITwapStrategyFactory.CreateStrategyParamsStruct]): string;
    encodeFunctionData(functionFragment: "defaultAllowedSlippage", values?: undefined): string;
    encodeFunctionData(functionFragment: "defaultAllowedSwapDeviation", values?: undefined): string;
    encodeFunctionData(functionFragment: "defaultProtocolPerformanceFeeRate", values?: undefined): string;
    encodeFunctionData(functionFragment: "defaultTwapPricePeriod", values?: undefined): string;
    encodeFunctionData(functionFragment: "denied", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "deny", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: "deployerProxy", values?: undefined): string;
    encodeFunctionData(functionFragment: "feeTo", values?: undefined): string;
    encodeFunctionData(functionFragment: "freezeEmergency", values?: undefined): string;
    encodeFunctionData(functionFragment: "freezeEmergencyFunctions", values?: undefined): string;
    encodeFunctionData(functionFragment: "getHeartBeat", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getProtocolPerformanceFeeRate", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
    encodeFunctionData(functionFragment: "isValidStrategy", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "pendingGovernance", values?: undefined): string;
    encodeFunctionData(functionFragment: "protocolFeeRate", values?: undefined): string;
    encodeFunctionData(functionFragment: "protocolPerformanceFeeRateByPool", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "protocolPerformanceFeeRateByStrategy", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setMinHeartbeat", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "strategyByIndex", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "strategyByManager", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "strategyCreationFee", values?: undefined): string;
    encodeFunctionData(functionFragment: "swapProxy", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalIndex", values?: undefined): string;
    encodeFunctionData(functionFragment: "twapPricePeriod", values: [PromiseOrValue<string>]): string;
    decodeFunctionResult(functionFragment: "MAX_DECIMAL", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_PROTOCOL_PERFORMANCE_FEES_RATE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "acceptGovernance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "algebraFactory", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "allowedSlippage", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "allowedSwapDeviation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "chainlinkRegistry", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeAllowedSlippage", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeAllowedSwapDeviation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeDefaultTwapPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeDefaultValues", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeFeeForStrategyCreation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeFeeTo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeGovernance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeProtocolFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeProtocolPerformanceFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeSwapProxy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claimFees", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "createStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "defaultAllowedSlippage", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "defaultAllowedSwapDeviation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "defaultProtocolPerformanceFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "defaultTwapPricePeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "denied", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "deny", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "deployerProxy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "feeTo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "freezeEmergency", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "freezeEmergencyFunctions", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getHeartBeat", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getProtocolPerformanceFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isValidStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pendingGovernance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "protocolFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "protocolPerformanceFeeRateByPool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "protocolPerformanceFeeRateByStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setMinHeartbeat", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyByIndex", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyByManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyCreationFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swapProxy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalIndex", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "twapPricePeriod", data: BytesLike): Result;
    events: {
        "ChangeAllowedSlippage(address,uint256)": EventFragment;
        "ChangeAllowedSwapDeviation(address,uint256)": EventFragment;
        "ChangeProtocolFee(uint256)": EventFragment;
        "ChangeProtocolPerformanceFee(address,uint256)": EventFragment;
        "ChangeStrategyCreationFee(uint256)": EventFragment;
        "ChangeSwapProxy(address)": EventFragment;
        "ClaimFees(address,uint256)": EventFragment;
        "EmergencyFrozen()": EventFragment;
        "NewStrategy(address,address)": EventFragment;
        "StrategyStatusChanged(bool)": EventFragment;
        "TwapPricePeriodChanged(address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "ChangeAllowedSlippage"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChangeAllowedSwapDeviation"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChangeProtocolFee"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChangeProtocolPerformanceFee"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChangeStrategyCreationFee"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ChangeSwapProxy"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ClaimFees"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "EmergencyFrozen"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "NewStrategy"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyStatusChanged"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TwapPricePeriodChanged"): EventFragment;
}
export interface ChangeAllowedSlippageEventObject {
    pool: string;
    value: BigNumber;
}
export type ChangeAllowedSlippageEvent = TypedEvent<[
    string,
    BigNumber
], ChangeAllowedSlippageEventObject>;
export type ChangeAllowedSlippageEventFilter = TypedEventFilter<ChangeAllowedSlippageEvent>;
export interface ChangeAllowedSwapDeviationEventObject {
    pool: string;
    value: BigNumber;
}
export type ChangeAllowedSwapDeviationEvent = TypedEvent<[
    string,
    BigNumber
], ChangeAllowedSwapDeviationEventObject>;
export type ChangeAllowedSwapDeviationEventFilter = TypedEventFilter<ChangeAllowedSwapDeviationEvent>;
export interface ChangeProtocolFeeEventObject {
    fee: BigNumber;
}
export type ChangeProtocolFeeEvent = TypedEvent<[
    BigNumber
], ChangeProtocolFeeEventObject>;
export type ChangeProtocolFeeEventFilter = TypedEventFilter<ChangeProtocolFeeEvent>;
export interface ChangeProtocolPerformanceFeeEventObject {
    strategyOrPool: string;
    _feeRate: BigNumber;
}
export type ChangeProtocolPerformanceFeeEvent = TypedEvent<[
    string,
    BigNumber
], ChangeProtocolPerformanceFeeEventObject>;
export type ChangeProtocolPerformanceFeeEventFilter = TypedEventFilter<ChangeProtocolPerformanceFeeEvent>;
export interface ChangeStrategyCreationFeeEventObject {
    amount: BigNumber;
}
export type ChangeStrategyCreationFeeEvent = TypedEvent<[
    BigNumber
], ChangeStrategyCreationFeeEventObject>;
export type ChangeStrategyCreationFeeEventFilter = TypedEventFilter<ChangeStrategyCreationFeeEvent>;
export interface ChangeSwapProxyEventObject {
    newSwapProxy: string;
}
export type ChangeSwapProxyEvent = TypedEvent<[
    string
], ChangeSwapProxyEventObject>;
export type ChangeSwapProxyEventFilter = TypedEventFilter<ChangeSwapProxyEvent>;
export interface ClaimFeesEventObject {
    to: string;
    amount: BigNumber;
}
export type ClaimFeesEvent = TypedEvent<[
    string,
    BigNumber
], ClaimFeesEventObject>;
export type ClaimFeesEventFilter = TypedEventFilter<ClaimFeesEvent>;
export interface EmergencyFrozenEventObject {
}
export type EmergencyFrozenEvent = TypedEvent<[], EmergencyFrozenEventObject>;
export type EmergencyFrozenEventFilter = TypedEventFilter<EmergencyFrozenEvent>;
export interface NewStrategyEventObject {
    strategy: string;
    creater: string;
}
export type NewStrategyEvent = TypedEvent<[
    string,
    string
], NewStrategyEventObject>;
export type NewStrategyEventFilter = TypedEventFilter<NewStrategyEvent>;
export interface StrategyStatusChangedEventObject {
    status: boolean;
}
export type StrategyStatusChangedEvent = TypedEvent<[
    boolean
], StrategyStatusChangedEventObject>;
export type StrategyStatusChangedEventFilter = TypedEventFilter<StrategyStatusChangedEvent>;
export interface TwapPricePeriodChangedEventObject {
    pool: string;
    period: BigNumber;
}
export type TwapPricePeriodChangedEvent = TypedEvent<[
    string,
    BigNumber
], TwapPricePeriodChangedEventObject>;
export type TwapPricePeriodChangedEventFilter = TypedEventFilter<TwapPricePeriodChangedEvent>;
export interface DefiedgeTwapFactory extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: DefiedgeTwapFactoryInterface;
    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: {
        MAX_DECIMAL(overrides?: CallOverrides): Promise<[BigNumber]>;
        MAX_PROTOCOL_PERFORMANCE_FEES_RATE(overrides?: CallOverrides): Promise<[BigNumber]>;
        acceptGovernance(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        algebraFactory(overrides?: CallOverrides): Promise<[string]>;
        allowedSlippage(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        allowedSwapDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        chainlinkRegistry(overrides?: CallOverrides): Promise<[string]>;
        changeAllowedSlippage(_pool: PromiseOrValue<string>, _allowedSlippage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        changeAllowedSwapDeviation(_pool: PromiseOrValue<string>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        changeDefaultTwapPeriod(_pool: PromiseOrValue<string>, _twapPricePeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        changeDefaultValues(_allowedSlippage: PromiseOrValue<BigNumberish>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        changeFeeForStrategyCreation(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        changeFeeTo(_feeTo: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        changeGovernance(_governance: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        changeProtocolFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        changeProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, _feeRate: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        changeSwapProxy(_swapProxy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        claimFees(_to: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        createStrategy(params: ITwapStrategyFactory.CreateStrategyParamsStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        defaultAllowedSlippage(overrides?: CallOverrides): Promise<[BigNumber]>;
        defaultAllowedSwapDeviation(overrides?: CallOverrides): Promise<[BigNumber]>;
        defaultProtocolPerformanceFeeRate(overrides?: CallOverrides): Promise<[BigNumber]>;
        defaultTwapPricePeriod(overrides?: CallOverrides): Promise<[BigNumber]>;
        denied(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        deny(_strategy: PromiseOrValue<string>, _status: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        deployerProxy(overrides?: CallOverrides): Promise<[string]>;
        feeTo(overrides?: CallOverrides): Promise<[string]>;
        freezeEmergency(overrides?: CallOverrides): Promise<[boolean]>;
        freezeEmergencyFunctions(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        getHeartBeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        getProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber] & {
            _feeRate: BigNumber;
        }>;
        governance(overrides?: CallOverrides): Promise<[string]>;
        isValidStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        pendingGovernance(overrides?: CallOverrides): Promise<[string]>;
        protocolFeeRate(overrides?: CallOverrides): Promise<[BigNumber]>;
        protocolPerformanceFeeRateByPool(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        protocolPerformanceFeeRateByStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        setMinHeartbeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, _period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        strategyByIndex(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
        strategyByManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>;
        strategyCreationFee(overrides?: CallOverrides): Promise<[BigNumber]>;
        swapProxy(overrides?: CallOverrides): Promise<[string]>;
        totalIndex(overrides?: CallOverrides): Promise<[BigNumber]>;
        twapPricePeriod(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
    };
    MAX_DECIMAL(overrides?: CallOverrides): Promise<BigNumber>;
    MAX_PROTOCOL_PERFORMANCE_FEES_RATE(overrides?: CallOverrides): Promise<BigNumber>;
    acceptGovernance(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    algebraFactory(overrides?: CallOverrides): Promise<string>;
    allowedSlippage(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    allowedSwapDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    chainlinkRegistry(overrides?: CallOverrides): Promise<string>;
    changeAllowedSlippage(_pool: PromiseOrValue<string>, _allowedSlippage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    changeAllowedSwapDeviation(_pool: PromiseOrValue<string>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    changeDefaultTwapPeriod(_pool: PromiseOrValue<string>, _twapPricePeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    changeDefaultValues(_allowedSlippage: PromiseOrValue<BigNumberish>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    changeFeeForStrategyCreation(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    changeFeeTo(_feeTo: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    changeGovernance(_governance: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    changeProtocolFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    changeProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, _feeRate: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    changeSwapProxy(_swapProxy: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    claimFees(_to: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    createStrategy(params: ITwapStrategyFactory.CreateStrategyParamsStruct, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    defaultAllowedSlippage(overrides?: CallOverrides): Promise<BigNumber>;
    defaultAllowedSwapDeviation(overrides?: CallOverrides): Promise<BigNumber>;
    defaultProtocolPerformanceFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
    defaultTwapPricePeriod(overrides?: CallOverrides): Promise<BigNumber>;
    denied(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    deny(_strategy: PromiseOrValue<string>, _status: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    deployerProxy(overrides?: CallOverrides): Promise<string>;
    feeTo(overrides?: CallOverrides): Promise<string>;
    freezeEmergency(overrides?: CallOverrides): Promise<boolean>;
    freezeEmergencyFunctions(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    getHeartBeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    getProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    governance(overrides?: CallOverrides): Promise<string>;
    isValidStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    pendingGovernance(overrides?: CallOverrides): Promise<string>;
    protocolFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
    protocolPerformanceFeeRateByPool(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    protocolPerformanceFeeRateByStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    setMinHeartbeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, _period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    strategyByIndex(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
    strategyByManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
    strategyCreationFee(overrides?: CallOverrides): Promise<BigNumber>;
    swapProxy(overrides?: CallOverrides): Promise<string>;
    totalIndex(overrides?: CallOverrides): Promise<BigNumber>;
    twapPricePeriod(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    callStatic: {
        MAX_DECIMAL(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_PROTOCOL_PERFORMANCE_FEES_RATE(overrides?: CallOverrides): Promise<BigNumber>;
        acceptGovernance(overrides?: CallOverrides): Promise<void>;
        algebraFactory(overrides?: CallOverrides): Promise<string>;
        allowedSlippage(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        allowedSwapDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        chainlinkRegistry(overrides?: CallOverrides): Promise<string>;
        changeAllowedSlippage(_pool: PromiseOrValue<string>, _allowedSlippage: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        changeAllowedSwapDeviation(_pool: PromiseOrValue<string>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        changeDefaultTwapPeriod(_pool: PromiseOrValue<string>, _twapPricePeriod: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        changeDefaultValues(_allowedSlippage: PromiseOrValue<BigNumberish>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        changeFeeForStrategyCreation(_fee: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        changeFeeTo(_feeTo: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        changeGovernance(_governance: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        changeProtocolFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        changeProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, _feeRate: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        changeSwapProxy(_swapProxy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        claimFees(_to: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        createStrategy(params: ITwapStrategyFactory.CreateStrategyParamsStruct, overrides?: CallOverrides): Promise<void>;
        defaultAllowedSlippage(overrides?: CallOverrides): Promise<BigNumber>;
        defaultAllowedSwapDeviation(overrides?: CallOverrides): Promise<BigNumber>;
        defaultProtocolPerformanceFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
        defaultTwapPricePeriod(overrides?: CallOverrides): Promise<BigNumber>;
        denied(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        deny(_strategy: PromiseOrValue<string>, _status: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        deployerProxy(overrides?: CallOverrides): Promise<string>;
        feeTo(overrides?: CallOverrides): Promise<string>;
        freezeEmergency(overrides?: CallOverrides): Promise<boolean>;
        freezeEmergencyFunctions(overrides?: CallOverrides): Promise<void>;
        getHeartBeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        governance(overrides?: CallOverrides): Promise<string>;
        isValidStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        pendingGovernance(overrides?: CallOverrides): Promise<string>;
        protocolFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
        protocolPerformanceFeeRateByPool(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        protocolPerformanceFeeRateByStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        setMinHeartbeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, _period: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        strategyByIndex(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        strategyByManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
        strategyCreationFee(overrides?: CallOverrides): Promise<BigNumber>;
        swapProxy(overrides?: CallOverrides): Promise<string>;
        totalIndex(overrides?: CallOverrides): Promise<BigNumber>;
        twapPricePeriod(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    };
    filters: {
        "ChangeAllowedSlippage(address,uint256)"(pool?: null, value?: null): ChangeAllowedSlippageEventFilter;
        ChangeAllowedSlippage(pool?: null, value?: null): ChangeAllowedSlippageEventFilter;
        "ChangeAllowedSwapDeviation(address,uint256)"(pool?: null, value?: null): ChangeAllowedSwapDeviationEventFilter;
        ChangeAllowedSwapDeviation(pool?: null, value?: null): ChangeAllowedSwapDeviationEventFilter;
        "ChangeProtocolFee(uint256)"(fee?: null): ChangeProtocolFeeEventFilter;
        ChangeProtocolFee(fee?: null): ChangeProtocolFeeEventFilter;
        "ChangeProtocolPerformanceFee(address,uint256)"(strategyOrPool?: null, _feeRate?: null): ChangeProtocolPerformanceFeeEventFilter;
        ChangeProtocolPerformanceFee(strategyOrPool?: null, _feeRate?: null): ChangeProtocolPerformanceFeeEventFilter;
        "ChangeStrategyCreationFee(uint256)"(amount?: null): ChangeStrategyCreationFeeEventFilter;
        ChangeStrategyCreationFee(amount?: null): ChangeStrategyCreationFeeEventFilter;
        "ChangeSwapProxy(address)"(newSwapProxy?: null): ChangeSwapProxyEventFilter;
        ChangeSwapProxy(newSwapProxy?: null): ChangeSwapProxyEventFilter;
        "ClaimFees(address,uint256)"(to?: null, amount?: null): ClaimFeesEventFilter;
        ClaimFees(to?: null, amount?: null): ClaimFeesEventFilter;
        "EmergencyFrozen()"(): EmergencyFrozenEventFilter;
        EmergencyFrozen(): EmergencyFrozenEventFilter;
        "NewStrategy(address,address)"(strategy?: PromiseOrValue<string> | null, creater?: PromiseOrValue<string> | null): NewStrategyEventFilter;
        NewStrategy(strategy?: PromiseOrValue<string> | null, creater?: PromiseOrValue<string> | null): NewStrategyEventFilter;
        "StrategyStatusChanged(bool)"(status?: null): StrategyStatusChangedEventFilter;
        StrategyStatusChanged(status?: null): StrategyStatusChangedEventFilter;
        "TwapPricePeriodChanged(address,uint256)"(pool?: null, period?: null): TwapPricePeriodChangedEventFilter;
        TwapPricePeriodChanged(pool?: null, period?: null): TwapPricePeriodChangedEventFilter;
    };
    estimateGas: {
        MAX_DECIMAL(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_PROTOCOL_PERFORMANCE_FEES_RATE(overrides?: CallOverrides): Promise<BigNumber>;
        acceptGovernance(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        algebraFactory(overrides?: CallOverrides): Promise<BigNumber>;
        allowedSlippage(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        allowedSwapDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        chainlinkRegistry(overrides?: CallOverrides): Promise<BigNumber>;
        changeAllowedSlippage(_pool: PromiseOrValue<string>, _allowedSlippage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        changeAllowedSwapDeviation(_pool: PromiseOrValue<string>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        changeDefaultTwapPeriod(_pool: PromiseOrValue<string>, _twapPricePeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        changeDefaultValues(_allowedSlippage: PromiseOrValue<BigNumberish>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        changeFeeForStrategyCreation(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        changeFeeTo(_feeTo: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        changeGovernance(_governance: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        changeProtocolFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        changeProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, _feeRate: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        changeSwapProxy(_swapProxy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        claimFees(_to: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        createStrategy(params: ITwapStrategyFactory.CreateStrategyParamsStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        defaultAllowedSlippage(overrides?: CallOverrides): Promise<BigNumber>;
        defaultAllowedSwapDeviation(overrides?: CallOverrides): Promise<BigNumber>;
        defaultProtocolPerformanceFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
        defaultTwapPricePeriod(overrides?: CallOverrides): Promise<BigNumber>;
        denied(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        deny(_strategy: PromiseOrValue<string>, _status: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        deployerProxy(overrides?: CallOverrides): Promise<BigNumber>;
        feeTo(overrides?: CallOverrides): Promise<BigNumber>;
        freezeEmergency(overrides?: CallOverrides): Promise<BigNumber>;
        freezeEmergencyFunctions(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        getHeartBeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        governance(overrides?: CallOverrides): Promise<BigNumber>;
        isValidStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        pendingGovernance(overrides?: CallOverrides): Promise<BigNumber>;
        protocolFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
        protocolPerformanceFeeRateByPool(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        protocolPerformanceFeeRateByStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        setMinHeartbeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, _period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        strategyByIndex(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        strategyByManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        strategyCreationFee(overrides?: CallOverrides): Promise<BigNumber>;
        swapProxy(overrides?: CallOverrides): Promise<BigNumber>;
        totalIndex(overrides?: CallOverrides): Promise<BigNumber>;
        twapPricePeriod(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        MAX_DECIMAL(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_PROTOCOL_PERFORMANCE_FEES_RATE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        acceptGovernance(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        algebraFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        allowedSlippage(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        allowedSwapDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        chainlinkRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        changeAllowedSlippage(_pool: PromiseOrValue<string>, _allowedSlippage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        changeAllowedSwapDeviation(_pool: PromiseOrValue<string>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        changeDefaultTwapPeriod(_pool: PromiseOrValue<string>, _twapPricePeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        changeDefaultValues(_allowedSlippage: PromiseOrValue<BigNumberish>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        changeFeeForStrategyCreation(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        changeFeeTo(_feeTo: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        changeGovernance(_governance: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        changeProtocolFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        changeProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, _feeRate: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        changeSwapProxy(_swapProxy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        claimFees(_to: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        createStrategy(params: ITwapStrategyFactory.CreateStrategyParamsStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        defaultAllowedSlippage(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        defaultAllowedSwapDeviation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        defaultProtocolPerformanceFeeRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        defaultTwapPricePeriod(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        denied(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        deny(_strategy: PromiseOrValue<string>, _status: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        deployerProxy(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        feeTo(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        freezeEmergency(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        freezeEmergencyFunctions(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        getHeartBeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        governance(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isValidStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pendingGovernance(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolFeeRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolPerformanceFeeRateByPool(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolPerformanceFeeRateByStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        setMinHeartbeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, _period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        strategyByIndex(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        strategyByManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        strategyCreationFee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        swapProxy(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalIndex(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        twapPricePeriod(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}
