import { DbProvider } from '../db-provider';
import { RebRecord, UniV3MMOptions } from '../types';
import { VaultProvider } from '../vaultProviders/vaultProvider';
import { MMStrategy } from './strategy';
import { UniV3Range } from '../uniV3Range';
import { Contract } from 'ethers';
export declare const defaultConfig: UniV3MMOptions;
export interface MaxLpStrategyParams extends Partial<UniV3MMOptions> {
    dbProvider?: DbProvider;
    useMovingAvg?: boolean;
}
interface State {
    rebalances: RebRecord[];
    prevBalances: [number, number];
    leftoverRebalance: [number, number];
}
export declare class MaxLpStrategy<TVaultProvider extends VaultProvider<Contract, string>> extends MMStrategy<TVaultProvider> {
    private initPromise;
    vaultProvider: TVaultProvider;
    dbProvider?: DbProvider;
    state: State;
    tempState: State;
    lastTimestamp: number;
    inventory: [number, number];
    allocated: [number, number];
    prevReb: number;
    movingAvg: number;
    maInterval: number;
    mainRangeOffset: number;
    secondaryRangeOffset: number;
    rebalanceWeight: number;
    mainRangeShare: number;
    secRangeShare: number;
    rebalanceLow: number;
    rebalanceHigh: number;
    useMovingAvg?: boolean;
    lastRebalanceBlockNumber?: number;
    isRebalancing: boolean;
    private constructor();
    static create<TVaultProvider extends VaultProvider<Contract, string>>(vaultProvider: TVaultProvider, params: MaxLpStrategyParams): Promise<MaxLpStrategy<TVaultProvider>>;
    ready(): Promise<void>;
    private init;
    update(): Promise<void>;
    initPosition(): Promise<void>;
    updateMovingAvg(reInit?: boolean): Promise<number>;
    getClosePositionParams(): Promise<ReturnType<TVaultProvider['getRebalanceParams']>>;
    rebalanceRanges(): Promise<ReturnType<TVaultProvider['getRebalanceParams']> | undefined>;
    syncToDB(): Promise<void>;
    logRanges(): void;
    findRangeAmounts(ranges: UniV3Range[], mainValue: number): Promise<{
        updatedRanges: UniV3Range[];
        leftoverRebalance: number[];
    }>;
    getExpectedCostBasis(low: UniV3Range, mainRange: UniV3Range, high: UniV3Range): Promise<{
        expectedCostBasis: number;
        leftoverRebalance: number[];
    }>;
    getBidAsk(price?: number): {
        bid: number;
        ask: number;
    };
    getRebalancePoints(prevReb?: number): {
        rebalanceLow: number;
        rebalanceHigh: number;
    };
    getRangeAmounts(mainLp: number, extraBase: number, extraQuote: number): {
        secBaseValue: number;
        secQuoteValue: number;
    };
    updateRebalanceRecord(): Promise<void>;
    getCostBasis(): Promise<RebRecord>;
    getRanges(price: number, tickSpacing: number): Promise<{
        mainLow: number;
        mainHigh: number;
        secRangeLow: number;
        secRangeHigh: number;
        rebalanceLow: number;
        rebalanceHigh: number;
    }>;
    syncFromDB(): Promise<void>;
    static initMMValue(key: string, field: string, value: string | number, dbProvider?: DbProvider): Promise<void>;
}
export {};
