import * as _alephium_web3 from '@alephium/web3';
import { ExecuteScriptResult, NetworkId, SignerProvider, Val, Address, HexString, ContractState, CallContractParams, CallContractResult, SignExecuteContractMethodParams, SignExecuteScriptTxResult, ContractFactory, ContractInstance, Narrow, TestContractParamsWithoutMaps, TestContractResultWithoutMaps, Asset, ContractEvent, EventSubscribeOptions, EventSubscription, Contract, ExecutableScript, RalphMap, TestContractParams, TestContractResult, Account, NodeProvider, ExplorerProvider, DeployContractExecutionResult, RunScriptResult } from '@alephium/web3';
import { TokenInfo } from '@alephium/token-list';
import Decimal from 'decimal.js';

interface CpmmConfig {
    groupIndex: number;
    factoryId: string;
    routerId: string;
    feeCollectorFactoryId?: string;
}
interface CpmmPoolContractState {
    poolId: string;
    reserve0: bigint;
    reserve1: bigint;
    token0Info: TokenInfo;
    token1Info: TokenInfo;
    totalSupply: bigint;
    dexAccount: string;
}
interface SwapParams$1 {
    tokenIn: TokenInfo;
    tokenOut: TokenInfo;
    amountIn?: bigint;
    amountOut?: bigint;
    slippage: bigint;
    sender: string;
    ttl?: number;
}
interface SwapDetails {
    swapType: 'ExactIn' | 'ExactOut';
    state: CpmmPoolContractState;
    tokenInInfo: TokenInfo;
    tokenOutInfo: TokenInfo;
    tokenInAmount: bigint;
    maximalTokenInAmount: bigint | undefined;
    tokenOutAmount: bigint;
    minimalTokenOutAmount: bigint | undefined;
    priceImpact: number;
}
interface AddLiquidityParams {
    cpmmPoolState: CpmmPoolContractState;
    tokenA: TokenInfo;
    tokenB: TokenInfo;
    amountA: bigint;
    amountB: bigint;
    slippage: bigint;
    sender: string;
    ttl?: number;
}
interface AddLiquidityDetails {
    state?: CpmmPoolContractState;
    tokenAId: string;
    tokenBId: string;
    amountA: bigint;
    amountB: bigint;
    shareAmount: bigint;
    sharePercentage: number;
}
interface RemoveLiquidityParams {
    state: CpmmPoolContractState;
    liquidity: bigint;
    totalLiquidityAmount?: bigint;
    slippage: bigint;
    sender: string;
    ttl?: number;
}
interface RemoveLiquidityDetails {
    state: CpmmPoolContractState;
    token0: TokenInfo;
    amount0: bigint;
    token1: TokenInfo;
    amount1: bigint;
    remainShareAmount: bigint;
    remainSharePercentage: number;
}
interface ClaimableAmounts {
    token0: TokenInfo;
    amount0: bigint;
    token1: TokenInfo;
    amount1: bigint;
}
interface CreatePoolParams {
    tokenA: TokenInfo;
    tokenB: TokenInfo;
    sender: string;
    tokenAAmount?: bigint;
    tokenBAmount?: bigint;
}
interface ComputeSwapParams {
    state: CpmmPoolContractState;
    tokenIn: TokenInfo;
    tokenOut: TokenInfo;
    amountIn?: bigint;
    amountOut?: bigint;
    slippage: bigint;
}
interface ComputeLiquidityParams {
    state?: CpmmPoolContractState;
    tokenA: TokenInfo;
    tokenB: TokenInfo;
    amountA?: bigint;
    amountB?: bigint;
    inputType?: 'TokenA' | 'TokenB';
}

declare enum LogLevel {
    Error = 0,
    Warning = 1,
    Info = 2,
    Debug = 3
}
declare class Logger {
    private logLevel;
    private name;
    constructor(params: {
        name: string;
        logLevel?: LogLevel;
    });
    set level(logLevel: LogLevel);
    get time(): string;
    get moduleName(): string;
    private isLogLevel;
    error(...props: unknown[]): Logger;
    logWithError(...props: unknown[]): Logger;
    warning(...props: unknown[]): Logger;
    info(...props: unknown[]): Logger;
    debug(...props: unknown[]): Logger;
}
declare function createLogger(moduleName: string): Logger;
declare function setLoggerLevel(moduleName: string, level: LogLevel): void;

interface ModuleBaseProps {
    scope: Zeta;
    moduleName: string;
}
declare class ModuleBase {
    scope: Zeta;
    private disabled;
    protected logger: Logger;
    constructor({ scope, moduleName }: ModuleBaseProps);
    logDebug(...args: unknown[]): void;
    logInfo(...args: unknown[]): void;
    logWarning(...args: unknown[]): void;
    logError(...args: unknown[]): void;
    logAndThrowError(...args: unknown[]): never;
    checkDisabled(): void;
}

declare class CpmmModule extends ModuleBase {
    private config;
    constructor(scope: Zeta);
    getPoolId(tokenA: string, tokenB: string): string;
    getPoolAddress(tokenA: string, tokenB: string): string;
    getPoolState(tokenA: string, tokenB: string): Promise<CpmmPoolContractState>;
    poolExists(tokenA: string, tokenB: string): Promise<boolean>;
    swap(params: SwapParams$1, balances?: Map<string, bigint>): Promise<ExecuteScriptResult>;
    addLiquidity(params: AddLiquidityParams, balances?: Map<string, bigint>): Promise<ExecuteScriptResult>;
    removeLiquidity(params: RemoveLiquidityParams): Promise<ExecuteScriptResult>;
    computeClaimableAmounts(tokenAId: string, tokenBId: string, liquidityBalance: bigint): Promise<ClaimableAmounts>;
    createPool(params: CreatePoolParams): Promise<ExecuteScriptResult & {
        poolId: string;
    }>;
    getCpmmConfig(): CpmmConfig;
    static computeSwapAmount(params: ComputeSwapParams): SwapDetails;
    static computeLiquidityAmounts(params: ComputeLiquidityParams): AddLiquidityDetails;
    static computeRemoveLiquidityAmounts(state: CpmmPoolContractState, totalLiquidity: bigint, liquidityToRemove: bigint): RemoveLiquidityDetails;
    static computeClaimableAmounts(state: CpmmPoolContractState, liquidityBalance: bigint): RemoveLiquidityDetails;
    static minimalAmount(amount: bigint, slippage: bigint): bigint;
    static maximalAmount(amount: bigint, slippage: bigint): bigint;
    private static assertSlippageInRange;
    static calcPriceImpact(reserve0: bigint, reserve1: bigint, tokenInId: string, token0Id: string, amountIn: bigint, amountOut: bigint): number;
    static getLiquidityDetails(state: CpmmPoolContractState, inputTokenId: string, inputAmount: bigint, inputType: 'TokenA' | 'TokenB'): {
        state: CpmmPoolContractState;
        tokenAId: string;
        tokenBId: string;
        amountA: bigint;
        amountB: bigint;
        shareAmount: bigint;
        sharePercentage: number;
    };
    static getAmountIn(state: CpmmPoolContractState, tokenOutId: string, amountOut: bigint): bigint;
    static getAmountOut(state: CpmmPoolContractState, tokenInId: string, amountIn: bigint): bigint;
    static getInitLiquidityDetails(tokenAId: string, tokenBId: string, amountA: bigint, amountB: bigint): {
        tokenAId: string;
        tokenBId: string;
        amountA: bigint;
        amountB: bigint;
        shareAmount: bigint;
        sharePercentage: number;
    };
    private static _getAmountOut;
    private getExtraAlphAmount;
}

interface Network {
    id: NetworkId;
    name: string;
    nodeUrl: string;
    nodeApiKey?: string;
    explorerApiUrl: string;
    explorerUrl: string;
    tokenListUrl: string;
}
declare const DEVNET: {
    id: NetworkId;
    nodeUrl: string;
    explorerApiUrl: string;
    explorerUrl: string;
    tokenListUrl: string;
    name: string;
};
declare const defaultNetworks: Network[];
type NetworkOverrides = Partial<Omit<Network, 'id'>>;
interface ZetaLoadParams {
    networkId: NetworkId;
    signer?: SignerProvider;
    networkOverrides?: NetworkOverrides;
}

interface CollectParams extends Record<string, Val> {
    token0: HexString;
    token1: HexString;
    configIndex: bigint;
    owner: Address;
    recipient: Address;
    tickLower: bigint;
    tickUpper: bigint;
    amount0Max: bigint;
    amount1Max: bigint;
}
interface Config extends Record<string, Val> {
    tickSpacing: bigint;
    fee: bigint;
    feeProtocol: bigint;
}
interface DecreaseLiquidityParams extends Record<string, Val> {
    token0: HexString;
    token1: HexString;
    configIndex: bigint;
    owner: Address;
    tickLower: bigint;
    tickUpper: bigint;
    amount0Min: bigint;
    amount1Min: bigint;
}
interface ModifyLiquidityParams extends Record<string, Val> {
    token0: HexString;
    token1: HexString;
    configIndex: bigint;
    owner: Address;
    tickLower: bigint;
    tickUpper: bigint;
    amount0Desired: bigint;
    amount1Desired: bigint;
    amount0Min: bigint;
    amount1Min: bigint;
}
interface ModifyPositionParams extends Record<string, Val> {
    owner: Address;
    tickLower: bigint;
    tickUpper: bigint;
    liquidityDelta: bigint;
}
interface PositionInfo extends Record<string, Val> {
    amount0: bigint;
    amount1: bigint;
    fees: [bigint, bigint, bigint];
    avgValue: bigint;
    avgFees: bigint;
    avgTime: bigint;
}
interface ProtocolFees extends Record<string, Val> {
    token0: bigint;
    token1: bigint;
}
interface Reward extends Record<string, Val> {
    nextOpenTime: bigint;
    endTime: bigint;
    amount: bigint;
}
interface Slot0 extends Record<string, Val> {
    sqrtPriceX96: bigint;
    tick: bigint;
    feeProtocol: bigint;
}
interface SwapParams extends Record<string, Val> {
    payer: Address;
    recipient: Address;
    token: HexString;
    payToken: HexString;
    toPay: bigint;
    withdrawToken: HexString;
    toWithdraw: bigint;
    data: HexString;
}

interface ClmmConfig {
    groupIndex: number;
    factoryId: string;
    positionManagerId: string;
    defaultConfigIndex: bigint;
    accountRoot: string;
}
interface ClmmSwapParams {
    token0: string;
    token1: string;
    amount: bigint;
    slippage: bigint;
    routePlan: bigint[];
}
interface SimulateSwap {
    configIndex: bigint;
    token0: string;
    token1: string;
    zeroForOne: boolean;
    amount: bigint;
}
interface LiquidityForPrice {
    liquidity: bigint;
    sqrtPriceX96: bigint;
}
interface LiquidityDistribution {
    baseSqrtPriceX96: bigint;
    sqrtPriceX96: bigint;
    liquidity: bigint;
    fee: bigint;
    rows: Array<LiquidityForPrice>;
}
interface AddLiquidity$1 {
    token0: string;
    token1: string;
    configIndex: bigint;
    owner?: string;
    tickLower: bigint;
    tickUpper: bigint;
    slippage: bigint;
    amount0: bigint;
    amount1: bigint;
    existingPosition?: boolean;
}
interface RemoveLiquidity$1 {
    token0: string;
    token1: string;
    configIndex: bigint;
    owner: string;
    tickLower: bigint;
    tickUpper: bigint;
    liquidity: bigint;
    base: 'token0' | 'token1';
    baseAmount: bigint;
    otherAmountMax: bigint;
}
interface CollectTokens {
    token0: string;
    token1: string;
    configIndex: bigint;
    owner: string;
    recipient: string;
    tickLower: bigint;
    tickUpper: bigint;
    liquidity: bigint;
    amount0Max: bigint;
    amount1Max: bigint;
}
interface PositionPath {
    poolId: string;
    owner: string;
    tickLower: bigint;
    tickUpper: bigint;
    acc: bigint;
    iacc0: bigint;
    iacc1: bigint;
    t0: bigint;
    acct0: bigint;
}
interface CollectProtocolFees {
    token0: string;
    token1: string;
    configIndex: bigint;
    recipient: string;
}
interface SetRewardParams {
    token0: string;
    token1: string;
    configIndex: bigint;
    rewardToken: string;
    payer: string;
    amount: bigint;
    openTime: bigint;
    endTime: bigint;
}
interface ExtendRewards {
    token0: string;
    token1: string;
    configIndex: bigint;
    rewardToken: string;
    payer: string;
    amount: bigint;
}
interface ClmmPoolContractState extends ClmmPoolConfig {
    poolId: string;
    token0Info: TokenInfo;
    token1Info: TokenInfo;
    liquidity: bigint;
    sqrtPriceX96: bigint;
    tick: bigint;
}
interface ClmmPoolConfig {
    configIndex: bigint;
    tickSpacing: bigint;
    tradingFee: bigint;
    protocolFee: bigint;
}
declare const MAX_PIPS: bigint;
type ClmmPositionInfo = PositionInfo;
interface GetPositionAmountsFromPriceProps {
    sqrtRatioX96: bigint;
    tokenBaseId: string;
    tokenQuoteId: string;
    lowerTick: bigint;
    upperTick: bigint;
    amountBase: bigint;
    amountQuote: bigint;
}
interface GetPositionAmountsFromPriceReturn {
    newAmountBase: bigint;
    newAmountQuote: bigint;
    liquidity: bigint;
}

declare namespace BitmapWordTypes {
    type Fields = {
        parent: Address;
        value: bigint;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        mostSignificantBit: {
            params: CallContractParams<{
                x: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        leastSignificantBit: {
            params: CallContractParams<{
                x: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        flip: {
            params: CallContractParams<{
                tick: bigint;
            }>;
            result: CallContractResult<null>;
        };
        getNext: {
            params: CallContractParams<{
                compressed: bigint;
                zeroForOne: boolean;
                tickSpacing: bigint;
            }>;
            result: CallContractResult<[bigint, boolean]>;
        };
        getBitPos: {
            params: CallContractParams<{
                tick: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        mostSignificantBit: {
            params: SignExecuteContractMethodParams<{
                x: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        leastSignificantBit: {
            params: SignExecuteContractMethodParams<{
                x: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        flip: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getNext: {
            params: SignExecuteContractMethodParams<{
                compressed: bigint;
                zeroForOne: boolean;
                tickSpacing: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getBitPos: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$w extends ContractFactory<BitmapWordInstance, BitmapWordTypes.Fields> {
    encodeFields(fields: BitmapWordTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        BitMathError: {
            NoMostSignificantBit: bigint;
            NoLeastSignificantBit: bigint;
        };
    };
    at(address: string): BitmapWordInstance;
    tests: {
        mostSignificantBit: (params: TestContractParamsWithoutMaps<BitmapWordTypes.Fields, {
            x: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        leastSignificantBit: (params: TestContractParamsWithoutMaps<BitmapWordTypes.Fields, {
            x: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        flip: (params: TestContractParamsWithoutMaps<BitmapWordTypes.Fields, {
            tick: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        getNext: (params: TestContractParamsWithoutMaps<BitmapWordTypes.Fields, {
            compressed: bigint;
            zeroForOne: boolean;
            tickSpacing: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, boolean]>>;
        getBitPos: (params: TestContractParamsWithoutMaps<BitmapWordTypes.Fields, {
            tick: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
    };
    stateForTest(initFields: BitmapWordTypes.Fields, asset?: Asset, address?: string): ContractState<BitmapWordTypes.Fields> | _alephium_web3.ContractStateWithMaps<BitmapWordTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const BitmapWord: Factory$w;
declare class BitmapWordInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<BitmapWordTypes.State>;
    view: {
        mostSignificantBit: (params: BitmapWordTypes.CallMethodParams<"mostSignificantBit">) => Promise<BitmapWordTypes.CallMethodResult<"mostSignificantBit">>;
        leastSignificantBit: (params: BitmapWordTypes.CallMethodParams<"leastSignificantBit">) => Promise<BitmapWordTypes.CallMethodResult<"leastSignificantBit">>;
        flip: (params: BitmapWordTypes.CallMethodParams<"flip">) => Promise<BitmapWordTypes.CallMethodResult<"flip">>;
        getNext: (params: BitmapWordTypes.CallMethodParams<"getNext">) => Promise<BitmapWordTypes.CallMethodResult<"getNext">>;
        getBitPos: (params: BitmapWordTypes.CallMethodParams<"getBitPos">) => Promise<BitmapWordTypes.CallMethodResult<"getBitPos">>;
    };
    transact: {
        mostSignificantBit: (params: BitmapWordTypes.SignExecuteMethodParams<"mostSignificantBit">) => Promise<BitmapWordTypes.SignExecuteMethodResult<"mostSignificantBit">>;
        leastSignificantBit: (params: BitmapWordTypes.SignExecuteMethodParams<"leastSignificantBit">) => Promise<BitmapWordTypes.SignExecuteMethodResult<"leastSignificantBit">>;
        flip: (params: BitmapWordTypes.SignExecuteMethodParams<"flip">) => Promise<BitmapWordTypes.SignExecuteMethodResult<"flip">>;
        getNext: (params: BitmapWordTypes.SignExecuteMethodParams<"getNext">) => Promise<BitmapWordTypes.SignExecuteMethodResult<"getNext">>;
        getBitPos: (params: BitmapWordTypes.SignExecuteMethodParams<"getBitPos">) => Promise<BitmapWordTypes.SignExecuteMethodResult<"getBitPos">>;
    };
    multicall<Calls extends BitmapWordTypes.MultiCallParams>(calls: Calls): Promise<BitmapWordTypes.MultiCallResults<Calls>>;
    multicall<Callss extends BitmapWordTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<BitmapWordTypes.MulticallReturnType<Callss>>;
}

declare namespace BitmapWordDeployerTypes {
    type State = Omit<ContractState<any>, "fields">;
    interface CallMethodTable {
        deploy: {
            params: CallContractParams<{
                payer: Address;
            }>;
            result: CallContractResult<HexString>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        deploy: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$v extends ContractFactory<BitmapWordDeployerInstance, {}> {
    encodeFields(): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    at(address: string): BitmapWordDeployerInstance;
    tests: {
        deploy: (params: Omit<TestContractParamsWithoutMaps<never, {
            payer: Address;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<HexString>>;
    };
    stateForTest(initFields: {}, asset?: Asset, address?: string): ContractState<{}> | _alephium_web3.ContractStateWithMaps<{}, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const BitmapWordDeployer: Factory$v;
declare class BitmapWordDeployerInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<BitmapWordDeployerTypes.State>;
    view: {
        deploy: (params: BitmapWordDeployerTypes.CallMethodParams<"deploy">) => Promise<BitmapWordDeployerTypes.CallMethodResult<"deploy">>;
    };
    transact: {
        deploy: (params: BitmapWordDeployerTypes.SignExecuteMethodParams<"deploy">) => Promise<BitmapWordDeployerTypes.SignExecuteMethodResult<"deploy">>;
    };
    multicall<Calls extends BitmapWordDeployerTypes.MultiCallParams>(calls: Calls): Promise<BitmapWordDeployerTypes.MultiCallResults<Calls>>;
    multicall<Callss extends BitmapWordDeployerTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<BitmapWordDeployerTypes.MulticallReturnType<Callss>>;
}

declare namespace DexAccountTypes$1 {
    type Fields = {
        parents: [HexString, HexString];
        owner: Address;
        refferer: Address;
        counter: bigint;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        deposit: {
            params: CallContractParams<{
                payer: Address;
                tokenId: HexString;
                amount: bigint;
                path: HexString;
                at: bigint;
            }>;
            result: CallContractResult<null>;
        };
        createAccount: {
            params: CallContractParams<{
                ref: Address;
            }>;
            result: CallContractResult<null>;
        };
        asRef: {
            params: CallContractParams<{
                defaultRef: Address;
            }>;
            result: CallContractResult<Address>;
        };
        updateCounter: {
            params: CallContractParams<{
                newCounter: bigint;
            }>;
            result: CallContractResult<null>;
        };
        setParents: {
            params: CallContractParams<{
                newParents: [HexString, HexString];
            }>;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        deposit: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                tokenId: HexString;
                amount: bigint;
                path: HexString;
                at: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        createAccount: {
            params: SignExecuteContractMethodParams<{
                ref: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        asRef: {
            params: SignExecuteContractMethodParams<{
                defaultRef: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        updateCounter: {
            params: SignExecuteContractMethodParams<{
                newCounter: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        setParents: {
            params: SignExecuteContractMethodParams<{
                newParents: [HexString, HexString];
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$u extends ContractFactory<DexAccountInstance$1, DexAccountTypes$1.Fields> {
    encodeFields(fields: DexAccountTypes$1.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    at(address: string): DexAccountInstance$1;
    tests: {
        deposit: (params: TestContractParamsWithoutMaps<DexAccountTypes$1.Fields, {
            payer: Address;
            tokenId: HexString;
            amount: bigint;
            path: HexString;
            at: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        createAccount: (params: TestContractParamsWithoutMaps<DexAccountTypes$1.Fields, {
            ref: Address;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        asRef: (params: TestContractParamsWithoutMaps<DexAccountTypes$1.Fields, {
            defaultRef: Address;
        }>) => Promise<TestContractResultWithoutMaps<Address>>;
        updateCounter: (params: TestContractParamsWithoutMaps<DexAccountTypes$1.Fields, {
            newCounter: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        setParents: (params: TestContractParamsWithoutMaps<DexAccountTypes$1.Fields, {
            newParents: [HexString, HexString];
        }>) => Promise<TestContractResultWithoutMaps<null>>;
    };
    stateForTest(initFields: DexAccountTypes$1.Fields, asset?: Asset, address?: string): ContractState<DexAccountTypes$1.Fields> | _alephium_web3.ContractStateWithMaps<DexAccountTypes$1.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const DexAccount$1: Factory$u;
declare class DexAccountInstance$1 extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<DexAccountTypes$1.State>;
    view: {
        deposit: (params: DexAccountTypes$1.CallMethodParams<"deposit">) => Promise<DexAccountTypes$1.CallMethodResult<"deposit">>;
        createAccount: (params: DexAccountTypes$1.CallMethodParams<"createAccount">) => Promise<DexAccountTypes$1.CallMethodResult<"createAccount">>;
        asRef: (params: DexAccountTypes$1.CallMethodParams<"asRef">) => Promise<DexAccountTypes$1.CallMethodResult<"asRef">>;
        updateCounter: (params: DexAccountTypes$1.CallMethodParams<"updateCounter">) => Promise<DexAccountTypes$1.CallMethodResult<"updateCounter">>;
        setParents: (params: DexAccountTypes$1.CallMethodParams<"setParents">) => Promise<DexAccountTypes$1.CallMethodResult<"setParents">>;
    };
    transact: {
        deposit: (params: DexAccountTypes$1.SignExecuteMethodParams<"deposit">) => Promise<DexAccountTypes$1.SignExecuteMethodResult<"deposit">>;
        createAccount: (params: DexAccountTypes$1.SignExecuteMethodParams<"createAccount">) => Promise<DexAccountTypes$1.SignExecuteMethodResult<"createAccount">>;
        asRef: (params: DexAccountTypes$1.SignExecuteMethodParams<"asRef">) => Promise<DexAccountTypes$1.SignExecuteMethodResult<"asRef">>;
        updateCounter: (params: DexAccountTypes$1.SignExecuteMethodParams<"updateCounter">) => Promise<DexAccountTypes$1.SignExecuteMethodResult<"updateCounter">>;
        setParents: (params: DexAccountTypes$1.SignExecuteMethodParams<"setParents">) => Promise<DexAccountTypes$1.SignExecuteMethodResult<"setParents">>;
    };
    multicall<Calls extends DexAccountTypes$1.MultiCallParams>(calls: Calls): Promise<DexAccountTypes$1.MultiCallResults<Calls>>;
    multicall<Callss extends DexAccountTypes$1.MultiCallParams[]>(callss: Narrow<Callss>): Promise<DexAccountTypes$1.MulticallReturnType<Callss>>;
}

declare namespace LiquidityAmountsTestTypes {
    type State = Omit<ContractState<any>, "fields">;
    interface CallMethodTable {
        getLiquidityForAmount0: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getLiquidityForAmount1: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount1: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getLiquidityForAmounts: {
            params: CallContractParams<{
                sqrtRatioX96: bigint;
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
                amount1: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getAmount0ForLiquidity: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidity: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        mulDiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        mulDivRoundingUp: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        getLiquidityForAmount0: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getLiquidityForAmount1: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount1: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getLiquidityForAmounts: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioX96: bigint;
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
                amount1: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getAmount0ForLiquidity: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidity: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDivRoundingUp: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$t extends ContractFactory<LiquidityAmountsTestInstance, {}> {
    encodeFields(): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        FullMathError: {
            MulDivOverflow: bigint;
        };
    };
    at(address: string): LiquidityAmountsTestInstance;
    tests: {
        getLiquidityForAmount0: (params: Omit<TestContractParamsWithoutMaps<never, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            amount0: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        getLiquidityForAmount1: (params: Omit<TestContractParamsWithoutMaps<never, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            amount1: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        getLiquidityForAmounts: (params: Omit<TestContractParamsWithoutMaps<never, {
            sqrtRatioX96: bigint;
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            amount0: bigint;
            amount1: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        getAmount0ForLiquidity: (params: Omit<TestContractParamsWithoutMaps<never, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            liquidity: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        mulDiv: (params: Omit<TestContractParamsWithoutMaps<never, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        mulDivRoundingUp: (params: Omit<TestContractParamsWithoutMaps<never, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
    };
    stateForTest(initFields: {}, asset?: Asset, address?: string): ContractState<{}> | _alephium_web3.ContractStateWithMaps<{}, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const LiquidityAmountsTest: Factory$t;
declare class LiquidityAmountsTestInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<LiquidityAmountsTestTypes.State>;
    view: {
        getLiquidityForAmount0: (params: LiquidityAmountsTestTypes.CallMethodParams<"getLiquidityForAmount0">) => Promise<LiquidityAmountsTestTypes.CallMethodResult<"getLiquidityForAmount0">>;
        getLiquidityForAmount1: (params: LiquidityAmountsTestTypes.CallMethodParams<"getLiquidityForAmount1">) => Promise<LiquidityAmountsTestTypes.CallMethodResult<"getLiquidityForAmount1">>;
        getLiquidityForAmounts: (params: LiquidityAmountsTestTypes.CallMethodParams<"getLiquidityForAmounts">) => Promise<LiquidityAmountsTestTypes.CallMethodResult<"getLiquidityForAmounts">>;
        getAmount0ForLiquidity: (params: LiquidityAmountsTestTypes.CallMethodParams<"getAmount0ForLiquidity">) => Promise<LiquidityAmountsTestTypes.CallMethodResult<"getAmount0ForLiquidity">>;
        mulDiv: (params: LiquidityAmountsTestTypes.CallMethodParams<"mulDiv">) => Promise<LiquidityAmountsTestTypes.CallMethodResult<"mulDiv">>;
        mulDivRoundingUp: (params: LiquidityAmountsTestTypes.CallMethodParams<"mulDivRoundingUp">) => Promise<LiquidityAmountsTestTypes.CallMethodResult<"mulDivRoundingUp">>;
    };
    transact: {
        getLiquidityForAmount0: (params: LiquidityAmountsTestTypes.SignExecuteMethodParams<"getLiquidityForAmount0">) => Promise<LiquidityAmountsTestTypes.SignExecuteMethodResult<"getLiquidityForAmount0">>;
        getLiquidityForAmount1: (params: LiquidityAmountsTestTypes.SignExecuteMethodParams<"getLiquidityForAmount1">) => Promise<LiquidityAmountsTestTypes.SignExecuteMethodResult<"getLiquidityForAmount1">>;
        getLiquidityForAmounts: (params: LiquidityAmountsTestTypes.SignExecuteMethodParams<"getLiquidityForAmounts">) => Promise<LiquidityAmountsTestTypes.SignExecuteMethodResult<"getLiquidityForAmounts">>;
        getAmount0ForLiquidity: (params: LiquidityAmountsTestTypes.SignExecuteMethodParams<"getAmount0ForLiquidity">) => Promise<LiquidityAmountsTestTypes.SignExecuteMethodResult<"getAmount0ForLiquidity">>;
        mulDiv: (params: LiquidityAmountsTestTypes.SignExecuteMethodParams<"mulDiv">) => Promise<LiquidityAmountsTestTypes.SignExecuteMethodResult<"mulDiv">>;
        mulDivRoundingUp: (params: LiquidityAmountsTestTypes.SignExecuteMethodParams<"mulDivRoundingUp">) => Promise<LiquidityAmountsTestTypes.SignExecuteMethodResult<"mulDivRoundingUp">>;
    };
    multicall<Calls extends LiquidityAmountsTestTypes.MultiCallParams>(calls: Calls): Promise<LiquidityAmountsTestTypes.MultiCallResults<Calls>>;
    multicall<Callss extends LiquidityAmountsTestTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<LiquidityAmountsTestTypes.MulticallReturnType<Callss>>;
}

declare namespace LiquidityManagmentTestTypes {
    type Fields = {
        parent: HexString;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        addLiquidity: {
            params: CallContractParams<{
                payer: Address;
                p: ModifyLiquidityParams;
            }>;
            result: CallContractResult<[bigint, bigint, bigint, HexString]>;
        };
        getLiquidityForAmount0: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getLiquidityForAmount1: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount1: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getLiquidityForAmounts: {
            params: CallContractParams<{
                sqrtRatioX96: bigint;
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
                amount1: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getAmount0ForLiquidity: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidity: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        mulDiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        mulDivRoundingUp: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        configPath: {
            params: CallContractParams<{
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        poolPath: {
            params: CallContractParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        poolContractId: {
            params: CallContractParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        positionPath: {
            params: CallContractParams<{
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        positionContractId: {
            params: CallContractParams<{
                pool: HexString;
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        getSqrtRatioAtTick: {
            params: CallContractParams<{
                tick: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getTickAtSqrtRatio: {
            params: CallContractParams<{
                sqrtPriceX96: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        addLiquidity: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                p: ModifyLiquidityParams;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getLiquidityForAmount0: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getLiquidityForAmount1: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount1: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getLiquidityForAmounts: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioX96: bigint;
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
                amount1: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getAmount0ForLiquidity: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidity: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDivRoundingUp: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        configPath: {
            params: SignExecuteContractMethodParams<{
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        poolPath: {
            params: SignExecuteContractMethodParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        poolContractId: {
            params: SignExecuteContractMethodParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        positionPath: {
            params: SignExecuteContractMethodParams<{
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        positionContractId: {
            params: SignExecuteContractMethodParams<{
                pool: HexString;
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getSqrtRatioAtTick: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getTickAtSqrtRatio: {
            params: SignExecuteContractMethodParams<{
                sqrtPriceX96: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$s extends ContractFactory<LiquidityManagmentTestInstance, LiquidityManagmentTestTypes.Fields> {
    encodeFields(fields: LiquidityManagmentTestTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        LiquidityManagmentError: {
            MintSlippage: bigint;
            BurnSlippage: bigint;
        };
        FullMathError: {
            MulDivOverflow: bigint;
        };
        PathPrefixes: {
            Tick: bigint;
            Position: bigint;
            Word: bigint;
        };
        TickMathError: {
            SqrtPriceX96OutOfBounds: bigint;
            TickOutOfBounds: bigint;
        };
    };
    at(address: string): LiquidityManagmentTestInstance;
    tests: {
        addLiquidity: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            payer: Address;
            p: ModifyLiquidityParams;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint, HexString]>>;
        getLiquidityForAmount0: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            amount0: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getLiquidityForAmount1: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            amount1: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getLiquidityForAmounts: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            sqrtRatioX96: bigint;
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            amount0: bigint;
            amount1: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getAmount0ForLiquidity: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            liquidity: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        mulDiv: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        mulDivRoundingUp: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        configPath: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        poolPath: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            factory: HexString;
            tokens: HexString;
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        poolContractId: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            factory: HexString;
            tokens: HexString;
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        positionPath: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            o: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        positionContractId: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            pool: HexString;
            o: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        getSqrtRatioAtTick: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            tick: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getTickAtSqrtRatio: (params: TestContractParamsWithoutMaps<LiquidityManagmentTestTypes.Fields, {
            sqrtPriceX96: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
    };
    stateForTest(initFields: LiquidityManagmentTestTypes.Fields, asset?: Asset, address?: string): ContractState<LiquidityManagmentTestTypes.Fields> | _alephium_web3.ContractStateWithMaps<LiquidityManagmentTestTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const LiquidityManagmentTest: Factory$s;
declare class LiquidityManagmentTestInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<LiquidityManagmentTestTypes.State>;
    view: {
        addLiquidity: (params: LiquidityManagmentTestTypes.CallMethodParams<"addLiquidity">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"addLiquidity">>;
        getLiquidityForAmount0: (params: LiquidityManagmentTestTypes.CallMethodParams<"getLiquidityForAmount0">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"getLiquidityForAmount0">>;
        getLiquidityForAmount1: (params: LiquidityManagmentTestTypes.CallMethodParams<"getLiquidityForAmount1">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"getLiquidityForAmount1">>;
        getLiquidityForAmounts: (params: LiquidityManagmentTestTypes.CallMethodParams<"getLiquidityForAmounts">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"getLiquidityForAmounts">>;
        getAmount0ForLiquidity: (params: LiquidityManagmentTestTypes.CallMethodParams<"getAmount0ForLiquidity">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"getAmount0ForLiquidity">>;
        mulDiv: (params: LiquidityManagmentTestTypes.CallMethodParams<"mulDiv">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"mulDiv">>;
        mulDivRoundingUp: (params: LiquidityManagmentTestTypes.CallMethodParams<"mulDivRoundingUp">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"mulDivRoundingUp">>;
        configPath: (params: LiquidityManagmentTestTypes.CallMethodParams<"configPath">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"configPath">>;
        poolPath: (params: LiquidityManagmentTestTypes.CallMethodParams<"poolPath">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"poolPath">>;
        poolContractId: (params: LiquidityManagmentTestTypes.CallMethodParams<"poolContractId">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"poolContractId">>;
        positionPath: (params: LiquidityManagmentTestTypes.CallMethodParams<"positionPath">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"positionPath">>;
        positionContractId: (params: LiquidityManagmentTestTypes.CallMethodParams<"positionContractId">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"positionContractId">>;
        getSqrtRatioAtTick: (params: LiquidityManagmentTestTypes.CallMethodParams<"getSqrtRatioAtTick">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"getSqrtRatioAtTick">>;
        getTickAtSqrtRatio: (params: LiquidityManagmentTestTypes.CallMethodParams<"getTickAtSqrtRatio">) => Promise<LiquidityManagmentTestTypes.CallMethodResult<"getTickAtSqrtRatio">>;
    };
    transact: {
        addLiquidity: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"addLiquidity">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"addLiquidity">>;
        getLiquidityForAmount0: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"getLiquidityForAmount0">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"getLiquidityForAmount0">>;
        getLiquidityForAmount1: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"getLiquidityForAmount1">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"getLiquidityForAmount1">>;
        getLiquidityForAmounts: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"getLiquidityForAmounts">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"getLiquidityForAmounts">>;
        getAmount0ForLiquidity: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"getAmount0ForLiquidity">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"getAmount0ForLiquidity">>;
        mulDiv: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"mulDiv">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"mulDiv">>;
        mulDivRoundingUp: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"mulDivRoundingUp">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"mulDivRoundingUp">>;
        configPath: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"configPath">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"configPath">>;
        poolPath: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"poolPath">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"poolPath">>;
        poolContractId: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"poolContractId">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"poolContractId">>;
        positionPath: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"positionPath">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"positionPath">>;
        positionContractId: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"positionContractId">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"positionContractId">>;
        getSqrtRatioAtTick: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"getSqrtRatioAtTick">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"getSqrtRatioAtTick">>;
        getTickAtSqrtRatio: (params: LiquidityManagmentTestTypes.SignExecuteMethodParams<"getTickAtSqrtRatio">) => Promise<LiquidityManagmentTestTypes.SignExecuteMethodResult<"getTickAtSqrtRatio">>;
    };
    multicall<Calls extends LiquidityManagmentTestTypes.MultiCallParams>(calls: Calls): Promise<LiquidityManagmentTestTypes.MultiCallResults<Calls>>;
    multicall<Callss extends LiquidityManagmentTestTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<LiquidityManagmentTestTypes.MulticallReturnType<Callss>>;
}

declare namespace PoolTypes {
    type Fields = {
        parent: HexString;
        positionTemplate: HexString;
        dexAccountTemplate: HexString;
        tickTemplate: HexString;
        wordTemplate: HexString;
        configIndex: bigint;
        token0: HexString;
        token1: HexString;
        token2: HexString;
        fee: bigint;
        tickSpacing: bigint;
        maxLiquidityPerTick: bigint;
        nextNftIndex: bigint;
        slot0: Slot0;
        liquidity: bigint;
        rewardInfos: [Reward, Reward, Reward];
        feeGrowths: [bigint, bigint, bigint];
        protocolFees: ProtocolFees;
    };
    type State = ContractState<Fields>;
    type InitializeEvent = ContractEvent<{
        sqrtPriceX96: bigint;
        tick: bigint;
    }>;
    type SwapStartEvent = ContractEvent<{
        sqrtPriceX96: bigint;
    }>;
    type SwapStepEvent = ContractEvent<{
        sqrtPriceX96: bigint;
        liquidity: bigint;
    }>;
    type SwapEvent = ContractEvent<{
        sender: Address;
        recipient: Address;
        amount0: bigint;
        amount1: bigint;
        sqrtPriceX96: bigint;
        liquidity: bigint;
        tick: bigint;
    }>;
    type MintEvent = ContractEvent<{
        sender: Address;
        owner: Address;
        tickLower: bigint;
        tickUpper: bigint;
        liquidity: bigint;
        amount0: bigint;
        amount1: bigint;
        timestamp: bigint;
    }>;
    type BurnEvent = ContractEvent<{
        operator: Address;
        owner: Address;
        tickLower: bigint;
        tickUpper: bigint;
        liquidity: bigint;
        amount0: bigint;
        amount1: bigint;
    }>;
    type CollectEvent = ContractEvent<{
        operator: Address;
        recipient: Address;
        owner: Address;
        tickLower: bigint;
        tickUpper: bigint;
        amount0: bigint;
        amount1: bigint;
        amount2: bigint;
    }>;
    type FeesEvent = ContractEvent<{
        owner: Address;
        tickLower: bigint;
        tickUpper: bigint;
        amount0: bigint;
        amount1: bigint;
        amount2: bigint;
        timestamp: bigint;
    }>;
    type CollectProtocolEvent = ContractEvent<{
        sender: Address;
        recipient: Address;
        amount0: bigint;
        amount1: bigint;
    }>;
    interface CallMethodTable {
        getCollectionUri: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        totalSupply: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        nftByIndex: {
            params: CallContractParams<{
                index: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        validateNFT: {
            params: CallContractParams<{
                nftId: HexString;
                nftIndex: bigint;
            }>;
            result: CallContractResult<null>;
        };
        getSqrtRatioAtTick: {
            params: CallContractParams<{
                tick: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getTickAtSqrtRatio: {
            params: CallContractParams<{
                sqrtPriceX96: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        computeSwapStep: {
            params: CallContractParams<{
                sqrtRatioCurrentX96: bigint;
                sqrtRatioTargetX96: bigint;
                liquidity_: bigint;
                amountRemaining: bigint;
                feePips: bigint;
            }>;
            result: CallContractResult<[bigint, bigint, bigint, bigint]>;
        };
        divRoundingUp: {
            params: CallContractParams<{
                x: bigint;
                y: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getNextSqrtPriceFromAmount0RoundingUp: {
            params: CallContractParams<{
                sqrtPX96: bigint;
                liquidity_: bigint;
                amount: bigint;
                add: boolean;
            }>;
            result: CallContractResult<bigint>;
        };
        getNextSqrtPriceFromAmount1RoundingDown: {
            params: CallContractParams<{
                sqrtPX96: bigint;
                liquidity_: bigint;
                amount: bigint;
                add: boolean;
            }>;
            result: CallContractResult<bigint>;
        };
        getNextSqrtPriceFromInput: {
            params: CallContractParams<{
                sqrtPX96: bigint;
                liquidity_: bigint;
                amountIn: bigint;
                zeroForOne: boolean;
            }>;
            result: CallContractResult<bigint>;
        };
        getNextSqrtPriceFromOutput: {
            params: CallContractParams<{
                sqrtPX96: bigint;
                liquidity_: bigint;
                amountOut: bigint;
                zeroForOne: boolean;
            }>;
            result: CallContractResult<bigint>;
        };
        getAmount0DeltaEx: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidityDelta: bigint;
                roundUp: boolean;
            }>;
            result: CallContractResult<bigint>;
        };
        getAmount0Delta: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidityDelta: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getAmount1DeltaEx: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidityDelta: bigint;
                roundUp: boolean;
            }>;
            result: CallContractResult<bigint>;
        };
        getAmount1Delta: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidityDelta: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        mulDiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        mulDivRoundingUp: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        wordPath: {
            params: CallContractParams<{
                compressed: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        getWord: {
            params: CallContractParams<{
                compressed: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        getWordOrTemplate: {
            params: CallContractParams<{
                compressed: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        flipTick: {
            params: CallContractParams<{
                tick: bigint;
            }>;
            result: CallContractResult<null>;
        };
        nextInitializedTickWithinOneWord: {
            params: CallContractParams<{
                tick: bigint;
                zeroForOne: boolean;
            }>;
            result: CallContractResult<[bigint, boolean]>;
        };
        positionPath: {
            params: CallContractParams<{
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        positionContractId: {
            params: CallContractParams<{
                pool: HexString;
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        configPath: {
            params: CallContractParams<{
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        poolPath: {
            params: CallContractParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        poolContractId: {
            params: CallContractParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        checkTicks: {
            params: CallContractParams<{
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<null>;
        };
        tickPath: {
            params: CallContractParams<{
                tick: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        toTick: {
            params: CallContractParams<{
                tick: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        getTick: {
            params: CallContractParams<{
                tick: bigint;
            }>;
            result: CallContractResult<[HexString, boolean]>;
        };
        toPosition: {
            params: CallContractParams<{
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        getPosition: {
            params: CallContractParams<{
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<[HexString, boolean]>;
        };
        getFeeGrowthInside: {
            params: CallContractParams<{
                tickLower: HexString;
                tickUpper: HexString;
            }>;
            result: CallContractResult<[bigint, bigint, bigint]>;
        };
        updatePosition: {
            params: CallContractParams<{
                position: HexString;
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
                liquidityDelta: bigint;
            }>;
            result: CallContractResult<[bigint, bigint, bigint]>;
        };
        modifyPosition: {
            params: CallContractParams<{
                position: HexString;
                params: ModifyPositionParams;
            }>;
            result: CallContractResult<[bigint, bigint, [bigint, bigint, bigint]]>;
        };
        mint: {
            params: CallContractParams<{
                payer: Address;
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
                amount: bigint;
            }>;
            result: CallContractResult<[bigint, bigint]>;
        };
        burn: {
            params: CallContractParams<{
                operator: Address;
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
                amount: bigint;
            }>;
            result: CallContractResult<[bigint, bigint]>;
        };
        collect: {
            params: CallContractParams<{
                operator: Address;
                recipient: Address;
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
                maxAmounts: [bigint, bigint, bigint];
            }>;
            result: CallContractResult<[bigint, bigint, bigint]>;
        };
        withdraw: {
            params: CallContractParams<{
                recipient: Address;
                amounts: [bigint, bigint, bigint];
            }>;
            result: CallContractResult<null>;
        };
        simulateSwap: {
            params: CallContractParams<{
                zeroForOne: boolean;
                amountSpecified: bigint;
                data: HexString;
                maxSteps: bigint;
            }>;
            result: CallContractResult<null>;
        };
        swap: {
            params: CallContractParams<{
                payer: Address;
                recipient: Address;
                token: HexString;
                zeroForOne: boolean;
                amountSpecified: bigint;
                sqrtPriceLimitX96: bigint;
                data: HexString;
            }>;
            result: CallContractResult<[bigint, bigint]>;
        };
        pop: {
            params: CallContractParams<{
                data: HexString;
                t: HexString;
                exactInput: boolean;
            }>;
            result: CallContractResult<[boolean, bigint, HexString, HexString]>;
        };
        swapExactOut: {
            params: CallContractParams<{
                p: SwapParams;
                refRewards: bigint;
            }>;
            result: CallContractResult<null>;
        };
        swapExactIn: {
            params: CallContractParams<{
                p: SwapParams;
                refRewards: bigint;
            }>;
            result: CallContractResult<null>;
        };
        getSqrtPricesX96: {
            params: CallContractParams<{
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<[bigint, bigint, bigint]>;
        };
        updateReward: {
            params: CallContractParams<{
                index: bigint;
                blockTime: bigint;
            }>;
            result: CallContractResult<null>;
        };
        updateRewards: {
            params: CallContractParams<{
                blockTime: bigint;
            }>;
            result: CallContractResult<null>;
        };
        extendRewards: {
            params: CallContractParams<{
                payer: Address;
                index: bigint;
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        setRewardParams: {
            params: CallContractParams<{
                payer: Address;
                index: bigint;
                openTime: bigint;
                endTime: bigint;
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        collectProtocolFees: {
            params: CallContractParams<{
                recipient: Address;
            }>;
            result: CallContractResult<null>;
        };
        positionInfo: {
            params: CallContractParams<{
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
                acc: bigint;
                iacc0: bigint;
                iacc1: bigint;
                t0: bigint;
                acct0: bigint;
            }>;
            result: CallContractResult<PositionInfo>;
        };
        getTokenUri: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        getCollectionUri: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        totalSupply: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        nftByIndex: {
            params: SignExecuteContractMethodParams<{
                index: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        validateNFT: {
            params: SignExecuteContractMethodParams<{
                nftId: HexString;
                nftIndex: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getSqrtRatioAtTick: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getTickAtSqrtRatio: {
            params: SignExecuteContractMethodParams<{
                sqrtPriceX96: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        computeSwapStep: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioCurrentX96: bigint;
                sqrtRatioTargetX96: bigint;
                liquidity_: bigint;
                amountRemaining: bigint;
                feePips: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        divRoundingUp: {
            params: SignExecuteContractMethodParams<{
                x: bigint;
                y: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getNextSqrtPriceFromAmount0RoundingUp: {
            params: SignExecuteContractMethodParams<{
                sqrtPX96: bigint;
                liquidity_: bigint;
                amount: bigint;
                add: boolean;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getNextSqrtPriceFromAmount1RoundingDown: {
            params: SignExecuteContractMethodParams<{
                sqrtPX96: bigint;
                liquidity_: bigint;
                amount: bigint;
                add: boolean;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getNextSqrtPriceFromInput: {
            params: SignExecuteContractMethodParams<{
                sqrtPX96: bigint;
                liquidity_: bigint;
                amountIn: bigint;
                zeroForOne: boolean;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getNextSqrtPriceFromOutput: {
            params: SignExecuteContractMethodParams<{
                sqrtPX96: bigint;
                liquidity_: bigint;
                amountOut: bigint;
                zeroForOne: boolean;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getAmount0DeltaEx: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidityDelta: bigint;
                roundUp: boolean;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getAmount0Delta: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidityDelta: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getAmount1DeltaEx: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidityDelta: bigint;
                roundUp: boolean;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getAmount1Delta: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidityDelta: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDivRoundingUp: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        wordPath: {
            params: SignExecuteContractMethodParams<{
                compressed: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getWord: {
            params: SignExecuteContractMethodParams<{
                compressed: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getWordOrTemplate: {
            params: SignExecuteContractMethodParams<{
                compressed: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        flipTick: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        nextInitializedTickWithinOneWord: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
                zeroForOne: boolean;
            }>;
            result: SignExecuteScriptTxResult;
        };
        positionPath: {
            params: SignExecuteContractMethodParams<{
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        positionContractId: {
            params: SignExecuteContractMethodParams<{
                pool: HexString;
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        configPath: {
            params: SignExecuteContractMethodParams<{
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        poolPath: {
            params: SignExecuteContractMethodParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        poolContractId: {
            params: SignExecuteContractMethodParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        checkTicks: {
            params: SignExecuteContractMethodParams<{
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        tickPath: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        toTick: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getTick: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        toPosition: {
            params: SignExecuteContractMethodParams<{
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getPosition: {
            params: SignExecuteContractMethodParams<{
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getFeeGrowthInside: {
            params: SignExecuteContractMethodParams<{
                tickLower: HexString;
                tickUpper: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        updatePosition: {
            params: SignExecuteContractMethodParams<{
                position: HexString;
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
                liquidityDelta: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        modifyPosition: {
            params: SignExecuteContractMethodParams<{
                position: HexString;
                params: ModifyPositionParams;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mint: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        burn: {
            params: SignExecuteContractMethodParams<{
                operator: Address;
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        collect: {
            params: SignExecuteContractMethodParams<{
                operator: Address;
                recipient: Address;
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
                maxAmounts: [bigint, bigint, bigint];
            }>;
            result: SignExecuteScriptTxResult;
        };
        withdraw: {
            params: SignExecuteContractMethodParams<{
                recipient: Address;
                amounts: [bigint, bigint, bigint];
            }>;
            result: SignExecuteScriptTxResult;
        };
        simulateSwap: {
            params: SignExecuteContractMethodParams<{
                zeroForOne: boolean;
                amountSpecified: bigint;
                data: HexString;
                maxSteps: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        swap: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                recipient: Address;
                token: HexString;
                zeroForOne: boolean;
                amountSpecified: bigint;
                sqrtPriceLimitX96: bigint;
                data: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        pop: {
            params: SignExecuteContractMethodParams<{
                data: HexString;
                t: HexString;
                exactInput: boolean;
            }>;
            result: SignExecuteScriptTxResult;
        };
        swapExactOut: {
            params: SignExecuteContractMethodParams<{
                p: SwapParams;
                refRewards: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        swapExactIn: {
            params: SignExecuteContractMethodParams<{
                p: SwapParams;
                refRewards: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getSqrtPricesX96: {
            params: SignExecuteContractMethodParams<{
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        updateReward: {
            params: SignExecuteContractMethodParams<{
                index: bigint;
                blockTime: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        updateRewards: {
            params: SignExecuteContractMethodParams<{
                blockTime: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        extendRewards: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                index: bigint;
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        setRewardParams: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                index: bigint;
                openTime: bigint;
                endTime: bigint;
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        collectProtocolFees: {
            params: SignExecuteContractMethodParams<{
                recipient: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        positionInfo: {
            params: SignExecuteContractMethodParams<{
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
                acc: bigint;
                iacc0: bigint;
                iacc1: bigint;
                t0: bigint;
                acct0: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getTokenUri: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$r extends ContractFactory<PoolInstance, PoolTypes.Fields> {
    encodeFields(fields: PoolTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    eventIndex: {
        Initialize: number;
        SwapStart: number;
        SwapStep: number;
        Swap: number;
        Mint: number;
        Burn: number;
        Collect: number;
        Fees: number;
        CollectProtocol: number;
    };
    consts: {
        MAX_PIPS: bigint;
        TickMathError: {
            SqrtPriceX96OutOfBounds: bigint;
            TickOutOfBounds: bigint;
        };
        SqrtPriceMathError: {
            SqrtFromAmountOverflow: bigint;
            QuotientTooHigh: bigint;
            PriceZero: bigint;
            NoLiquidity: bigint;
            PriceNotFitIn160: bigint;
        };
        FullMathError: {
            MulDivOverflow: bigint;
        };
        TickBitmapError: {
            TickNotAligned: bigint;
        };
        PathPrefixes: {
            Tick: bigint;
            Position: bigint;
            Word: bigint;
        };
        PoolError: {
            TLU: bigint;
            TLM: bigint;
            TUM: bigint;
            AS: bigint;
            SPL: bigint;
            NP: bigint;
            UnauthorizedMint: bigint;
            NFTNotPartOfCollection: bigint;
            NFTByIndexNotSupported: bigint;
            UnauthorizedRewardSender: bigint;
            InvalidRewardParams: bigint;
            DexAccountNotFound: bigint;
            InvalidRewardIndex: bigint;
            RewardPeriodEnded: bigint;
            ZeroRewardAmount: bigint;
        };
    };
    at(address: string): PoolInstance;
    tests: {
        getCollectionUri: (params: Omit<TestContractParamsWithoutMaps<PoolTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<HexString>>;
        totalSupply: (params: Omit<TestContractParamsWithoutMaps<PoolTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        nftByIndex: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            index: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        validateNFT: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            nftId: HexString;
            nftIndex: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        getSqrtRatioAtTick: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            tick: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getTickAtSqrtRatio: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            sqrtPriceX96: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        computeSwapStep: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            sqrtRatioCurrentX96: bigint;
            sqrtRatioTargetX96: bigint;
            liquidity_: bigint;
            amountRemaining: bigint;
            feePips: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint, bigint]>>;
        divRoundingUp: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            x: bigint;
            y: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getNextSqrtPriceFromAmount0RoundingUp: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            sqrtPX96: bigint;
            liquidity_: bigint;
            amount: bigint;
            add: boolean;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getNextSqrtPriceFromAmount1RoundingDown: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            sqrtPX96: bigint;
            liquidity_: bigint;
            amount: bigint;
            add: boolean;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getNextSqrtPriceFromInput: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            sqrtPX96: bigint;
            liquidity_: bigint;
            amountIn: bigint;
            zeroForOne: boolean;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getNextSqrtPriceFromOutput: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            sqrtPX96: bigint;
            liquidity_: bigint;
            amountOut: bigint;
            zeroForOne: boolean;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getAmount0DeltaEx: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            liquidityDelta: bigint;
            roundUp: boolean;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getAmount0Delta: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            liquidityDelta: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getAmount1DeltaEx: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            liquidityDelta: bigint;
            roundUp: boolean;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getAmount1Delta: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            liquidityDelta: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        mulDiv: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        mulDivRoundingUp: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        wordPath: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            compressed: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        getWord: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            compressed: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        getWordOrTemplate: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            compressed: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        flipTick: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            tick: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        nextInitializedTickWithinOneWord: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            tick: bigint;
            zeroForOne: boolean;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, boolean]>>;
        positionPath: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            o: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        positionContractId: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            pool: HexString;
            o: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        configPath: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        poolPath: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            factory: HexString;
            tokens: HexString;
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        poolContractId: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            factory: HexString;
            tokens: HexString;
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        checkTicks: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        tickPath: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            tick: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        toTick: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            tick: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        getTick: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            tick: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[HexString, boolean]>>;
        toPosition: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            owner: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        getPosition: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            owner: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[HexString, boolean]>>;
        getFeeGrowthInside: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            tickLower: HexString;
            tickUpper: HexString;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
        updatePosition: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            position: HexString;
            owner: Address;
            tickLower: bigint;
            tickUpper: bigint;
            liquidityDelta: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
        modifyPosition: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            position: HexString;
            params: ModifyPositionParams;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, [bigint, bigint, bigint]]>>;
        mint: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            payer: Address;
            owner: Address;
            tickLower: bigint;
            tickUpper: bigint;
            amount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        burn: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            operator: Address;
            owner: Address;
            tickLower: bigint;
            tickUpper: bigint;
            amount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        collect: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            operator: Address;
            recipient: Address;
            owner: Address;
            tickLower: bigint;
            tickUpper: bigint;
            maxAmounts: [bigint, bigint, bigint];
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
        withdraw: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            recipient: Address;
            amounts: [bigint, bigint, bigint];
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        simulateSwap: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            zeroForOne: boolean;
            amountSpecified: bigint;
            data: HexString;
            maxSteps: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        swap: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            payer: Address;
            recipient: Address;
            token: HexString;
            zeroForOne: boolean;
            amountSpecified: bigint;
            sqrtPriceLimitX96: bigint;
            data: HexString;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        pop: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            data: HexString;
            t: HexString;
            exactInput: boolean;
        }>) => Promise<TestContractResultWithoutMaps<[boolean, bigint, HexString, HexString]>>;
        swapExactOut: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            p: SwapParams;
            refRewards: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        swapExactIn: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            p: SwapParams;
            refRewards: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        getSqrtPricesX96: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
        updateReward: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            index: bigint;
            blockTime: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        updateRewards: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            blockTime: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        extendRewards: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            payer: Address;
            index: bigint;
            amount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        setRewardParams: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            payer: Address;
            index: bigint;
            openTime: bigint;
            endTime: bigint;
            amount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        collectProtocolFees: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            recipient: Address;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        positionInfo: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
            owner: Address;
            tickLower: bigint;
            tickUpper: bigint;
            acc: bigint;
            iacc0: bigint;
            iacc1: bigint;
            t0: bigint;
            acct0: bigint;
        }>) => Promise<TestContractResultWithoutMaps<PositionInfo>>;
        getTokenUri: (params: Omit<TestContractParamsWithoutMaps<PoolTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<HexString>>;
    };
    stateForTest(initFields: PoolTypes.Fields, asset?: Asset, address?: string): ContractState<PoolTypes.Fields> | _alephium_web3.ContractStateWithMaps<PoolTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const Pool: Factory$r;
declare class PoolInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<PoolTypes.State>;
    getContractEventsCurrentCount(): Promise<number>;
    subscribeInitializeEvent(options: EventSubscribeOptions<PoolTypes.InitializeEvent>, fromCount?: number): EventSubscription;
    subscribeSwapStartEvent(options: EventSubscribeOptions<PoolTypes.SwapStartEvent>, fromCount?: number): EventSubscription;
    subscribeSwapStepEvent(options: EventSubscribeOptions<PoolTypes.SwapStepEvent>, fromCount?: number): EventSubscription;
    subscribeSwapEvent(options: EventSubscribeOptions<PoolTypes.SwapEvent>, fromCount?: number): EventSubscription;
    subscribeMintEvent(options: EventSubscribeOptions<PoolTypes.MintEvent>, fromCount?: number): EventSubscription;
    subscribeBurnEvent(options: EventSubscribeOptions<PoolTypes.BurnEvent>, fromCount?: number): EventSubscription;
    subscribeCollectEvent(options: EventSubscribeOptions<PoolTypes.CollectEvent>, fromCount?: number): EventSubscription;
    subscribeFeesEvent(options: EventSubscribeOptions<PoolTypes.FeesEvent>, fromCount?: number): EventSubscription;
    subscribeCollectProtocolEvent(options: EventSubscribeOptions<PoolTypes.CollectProtocolEvent>, fromCount?: number): EventSubscription;
    subscribeAllEvents(options: EventSubscribeOptions<PoolTypes.InitializeEvent | PoolTypes.SwapStartEvent | PoolTypes.SwapStepEvent | PoolTypes.SwapEvent | PoolTypes.MintEvent | PoolTypes.BurnEvent | PoolTypes.CollectEvent | PoolTypes.FeesEvent | PoolTypes.CollectProtocolEvent>, fromCount?: number): EventSubscription;
    view: {
        getCollectionUri: (params?: PoolTypes.CallMethodParams<"getCollectionUri">) => Promise<PoolTypes.CallMethodResult<"getCollectionUri">>;
        totalSupply: (params?: PoolTypes.CallMethodParams<"totalSupply">) => Promise<PoolTypes.CallMethodResult<"totalSupply">>;
        nftByIndex: (params: PoolTypes.CallMethodParams<"nftByIndex">) => Promise<PoolTypes.CallMethodResult<"nftByIndex">>;
        validateNFT: (params: PoolTypes.CallMethodParams<"validateNFT">) => Promise<PoolTypes.CallMethodResult<"validateNFT">>;
        getSqrtRatioAtTick: (params: PoolTypes.CallMethodParams<"getSqrtRatioAtTick">) => Promise<PoolTypes.CallMethodResult<"getSqrtRatioAtTick">>;
        getTickAtSqrtRatio: (params: PoolTypes.CallMethodParams<"getTickAtSqrtRatio">) => Promise<PoolTypes.CallMethodResult<"getTickAtSqrtRatio">>;
        computeSwapStep: (params: PoolTypes.CallMethodParams<"computeSwapStep">) => Promise<PoolTypes.CallMethodResult<"computeSwapStep">>;
        divRoundingUp: (params: PoolTypes.CallMethodParams<"divRoundingUp">) => Promise<PoolTypes.CallMethodResult<"divRoundingUp">>;
        getNextSqrtPriceFromAmount0RoundingUp: (params: PoolTypes.CallMethodParams<"getNextSqrtPriceFromAmount0RoundingUp">) => Promise<PoolTypes.CallMethodResult<"getNextSqrtPriceFromAmount0RoundingUp">>;
        getNextSqrtPriceFromAmount1RoundingDown: (params: PoolTypes.CallMethodParams<"getNextSqrtPriceFromAmount1RoundingDown">) => Promise<PoolTypes.CallMethodResult<"getNextSqrtPriceFromAmount1RoundingDown">>;
        getNextSqrtPriceFromInput: (params: PoolTypes.CallMethodParams<"getNextSqrtPriceFromInput">) => Promise<PoolTypes.CallMethodResult<"getNextSqrtPriceFromInput">>;
        getNextSqrtPriceFromOutput: (params: PoolTypes.CallMethodParams<"getNextSqrtPriceFromOutput">) => Promise<PoolTypes.CallMethodResult<"getNextSqrtPriceFromOutput">>;
        getAmount0DeltaEx: (params: PoolTypes.CallMethodParams<"getAmount0DeltaEx">) => Promise<PoolTypes.CallMethodResult<"getAmount0DeltaEx">>;
        getAmount0Delta: (params: PoolTypes.CallMethodParams<"getAmount0Delta">) => Promise<PoolTypes.CallMethodResult<"getAmount0Delta">>;
        getAmount1DeltaEx: (params: PoolTypes.CallMethodParams<"getAmount1DeltaEx">) => Promise<PoolTypes.CallMethodResult<"getAmount1DeltaEx">>;
        getAmount1Delta: (params: PoolTypes.CallMethodParams<"getAmount1Delta">) => Promise<PoolTypes.CallMethodResult<"getAmount1Delta">>;
        mulDiv: (params: PoolTypes.CallMethodParams<"mulDiv">) => Promise<PoolTypes.CallMethodResult<"mulDiv">>;
        mulDivRoundingUp: (params: PoolTypes.CallMethodParams<"mulDivRoundingUp">) => Promise<PoolTypes.CallMethodResult<"mulDivRoundingUp">>;
        wordPath: (params: PoolTypes.CallMethodParams<"wordPath">) => Promise<PoolTypes.CallMethodResult<"wordPath">>;
        getWord: (params: PoolTypes.CallMethodParams<"getWord">) => Promise<PoolTypes.CallMethodResult<"getWord">>;
        getWordOrTemplate: (params: PoolTypes.CallMethodParams<"getWordOrTemplate">) => Promise<PoolTypes.CallMethodResult<"getWordOrTemplate">>;
        flipTick: (params: PoolTypes.CallMethodParams<"flipTick">) => Promise<PoolTypes.CallMethodResult<"flipTick">>;
        nextInitializedTickWithinOneWord: (params: PoolTypes.CallMethodParams<"nextInitializedTickWithinOneWord">) => Promise<PoolTypes.CallMethodResult<"nextInitializedTickWithinOneWord">>;
        positionPath: (params: PoolTypes.CallMethodParams<"positionPath">) => Promise<PoolTypes.CallMethodResult<"positionPath">>;
        positionContractId: (params: PoolTypes.CallMethodParams<"positionContractId">) => Promise<PoolTypes.CallMethodResult<"positionContractId">>;
        configPath: (params: PoolTypes.CallMethodParams<"configPath">) => Promise<PoolTypes.CallMethodResult<"configPath">>;
        poolPath: (params: PoolTypes.CallMethodParams<"poolPath">) => Promise<PoolTypes.CallMethodResult<"poolPath">>;
        poolContractId: (params: PoolTypes.CallMethodParams<"poolContractId">) => Promise<PoolTypes.CallMethodResult<"poolContractId">>;
        checkTicks: (params: PoolTypes.CallMethodParams<"checkTicks">) => Promise<PoolTypes.CallMethodResult<"checkTicks">>;
        tickPath: (params: PoolTypes.CallMethodParams<"tickPath">) => Promise<PoolTypes.CallMethodResult<"tickPath">>;
        toTick: (params: PoolTypes.CallMethodParams<"toTick">) => Promise<PoolTypes.CallMethodResult<"toTick">>;
        getTick: (params: PoolTypes.CallMethodParams<"getTick">) => Promise<PoolTypes.CallMethodResult<"getTick">>;
        toPosition: (params: PoolTypes.CallMethodParams<"toPosition">) => Promise<PoolTypes.CallMethodResult<"toPosition">>;
        getPosition: (params: PoolTypes.CallMethodParams<"getPosition">) => Promise<PoolTypes.CallMethodResult<"getPosition">>;
        getFeeGrowthInside: (params: PoolTypes.CallMethodParams<"getFeeGrowthInside">) => Promise<PoolTypes.CallMethodResult<"getFeeGrowthInside">>;
        updatePosition: (params: PoolTypes.CallMethodParams<"updatePosition">) => Promise<PoolTypes.CallMethodResult<"updatePosition">>;
        modifyPosition: (params: PoolTypes.CallMethodParams<"modifyPosition">) => Promise<PoolTypes.CallMethodResult<"modifyPosition">>;
        mint: (params: PoolTypes.CallMethodParams<"mint">) => Promise<PoolTypes.CallMethodResult<"mint">>;
        burn: (params: PoolTypes.CallMethodParams<"burn">) => Promise<PoolTypes.CallMethodResult<"burn">>;
        collect: (params: PoolTypes.CallMethodParams<"collect">) => Promise<PoolTypes.CallMethodResult<"collect">>;
        withdraw: (params: PoolTypes.CallMethodParams<"withdraw">) => Promise<PoolTypes.CallMethodResult<"withdraw">>;
        simulateSwap: (params: PoolTypes.CallMethodParams<"simulateSwap">) => Promise<PoolTypes.CallMethodResult<"simulateSwap">>;
        swap: (params: PoolTypes.CallMethodParams<"swap">) => Promise<PoolTypes.CallMethodResult<"swap">>;
        pop: (params: PoolTypes.CallMethodParams<"pop">) => Promise<PoolTypes.CallMethodResult<"pop">>;
        swapExactOut: (params: PoolTypes.CallMethodParams<"swapExactOut">) => Promise<PoolTypes.CallMethodResult<"swapExactOut">>;
        swapExactIn: (params: PoolTypes.CallMethodParams<"swapExactIn">) => Promise<PoolTypes.CallMethodResult<"swapExactIn">>;
        getSqrtPricesX96: (params: PoolTypes.CallMethodParams<"getSqrtPricesX96">) => Promise<PoolTypes.CallMethodResult<"getSqrtPricesX96">>;
        updateReward: (params: PoolTypes.CallMethodParams<"updateReward">) => Promise<PoolTypes.CallMethodResult<"updateReward">>;
        updateRewards: (params: PoolTypes.CallMethodParams<"updateRewards">) => Promise<PoolTypes.CallMethodResult<"updateRewards">>;
        extendRewards: (params: PoolTypes.CallMethodParams<"extendRewards">) => Promise<PoolTypes.CallMethodResult<"extendRewards">>;
        setRewardParams: (params: PoolTypes.CallMethodParams<"setRewardParams">) => Promise<PoolTypes.CallMethodResult<"setRewardParams">>;
        collectProtocolFees: (params: PoolTypes.CallMethodParams<"collectProtocolFees">) => Promise<PoolTypes.CallMethodResult<"collectProtocolFees">>;
        positionInfo: (params: PoolTypes.CallMethodParams<"positionInfo">) => Promise<PoolTypes.CallMethodResult<"positionInfo">>;
        getTokenUri: (params?: PoolTypes.CallMethodParams<"getTokenUri">) => Promise<PoolTypes.CallMethodResult<"getTokenUri">>;
    };
    transact: {
        getCollectionUri: (params: PoolTypes.SignExecuteMethodParams<"getCollectionUri">) => Promise<PoolTypes.SignExecuteMethodResult<"getCollectionUri">>;
        totalSupply: (params: PoolTypes.SignExecuteMethodParams<"totalSupply">) => Promise<PoolTypes.SignExecuteMethodResult<"totalSupply">>;
        nftByIndex: (params: PoolTypes.SignExecuteMethodParams<"nftByIndex">) => Promise<PoolTypes.SignExecuteMethodResult<"nftByIndex">>;
        validateNFT: (params: PoolTypes.SignExecuteMethodParams<"validateNFT">) => Promise<PoolTypes.SignExecuteMethodResult<"validateNFT">>;
        getSqrtRatioAtTick: (params: PoolTypes.SignExecuteMethodParams<"getSqrtRatioAtTick">) => Promise<PoolTypes.SignExecuteMethodResult<"getSqrtRatioAtTick">>;
        getTickAtSqrtRatio: (params: PoolTypes.SignExecuteMethodParams<"getTickAtSqrtRatio">) => Promise<PoolTypes.SignExecuteMethodResult<"getTickAtSqrtRatio">>;
        computeSwapStep: (params: PoolTypes.SignExecuteMethodParams<"computeSwapStep">) => Promise<PoolTypes.SignExecuteMethodResult<"computeSwapStep">>;
        divRoundingUp: (params: PoolTypes.SignExecuteMethodParams<"divRoundingUp">) => Promise<PoolTypes.SignExecuteMethodResult<"divRoundingUp">>;
        getNextSqrtPriceFromAmount0RoundingUp: (params: PoolTypes.SignExecuteMethodParams<"getNextSqrtPriceFromAmount0RoundingUp">) => Promise<PoolTypes.SignExecuteMethodResult<"getNextSqrtPriceFromAmount0RoundingUp">>;
        getNextSqrtPriceFromAmount1RoundingDown: (params: PoolTypes.SignExecuteMethodParams<"getNextSqrtPriceFromAmount1RoundingDown">) => Promise<PoolTypes.SignExecuteMethodResult<"getNextSqrtPriceFromAmount1RoundingDown">>;
        getNextSqrtPriceFromInput: (params: PoolTypes.SignExecuteMethodParams<"getNextSqrtPriceFromInput">) => Promise<PoolTypes.SignExecuteMethodResult<"getNextSqrtPriceFromInput">>;
        getNextSqrtPriceFromOutput: (params: PoolTypes.SignExecuteMethodParams<"getNextSqrtPriceFromOutput">) => Promise<PoolTypes.SignExecuteMethodResult<"getNextSqrtPriceFromOutput">>;
        getAmount0DeltaEx: (params: PoolTypes.SignExecuteMethodParams<"getAmount0DeltaEx">) => Promise<PoolTypes.SignExecuteMethodResult<"getAmount0DeltaEx">>;
        getAmount0Delta: (params: PoolTypes.SignExecuteMethodParams<"getAmount0Delta">) => Promise<PoolTypes.SignExecuteMethodResult<"getAmount0Delta">>;
        getAmount1DeltaEx: (params: PoolTypes.SignExecuteMethodParams<"getAmount1DeltaEx">) => Promise<PoolTypes.SignExecuteMethodResult<"getAmount1DeltaEx">>;
        getAmount1Delta: (params: PoolTypes.SignExecuteMethodParams<"getAmount1Delta">) => Promise<PoolTypes.SignExecuteMethodResult<"getAmount1Delta">>;
        mulDiv: (params: PoolTypes.SignExecuteMethodParams<"mulDiv">) => Promise<PoolTypes.SignExecuteMethodResult<"mulDiv">>;
        mulDivRoundingUp: (params: PoolTypes.SignExecuteMethodParams<"mulDivRoundingUp">) => Promise<PoolTypes.SignExecuteMethodResult<"mulDivRoundingUp">>;
        wordPath: (params: PoolTypes.SignExecuteMethodParams<"wordPath">) => Promise<PoolTypes.SignExecuteMethodResult<"wordPath">>;
        getWord: (params: PoolTypes.SignExecuteMethodParams<"getWord">) => Promise<PoolTypes.SignExecuteMethodResult<"getWord">>;
        getWordOrTemplate: (params: PoolTypes.SignExecuteMethodParams<"getWordOrTemplate">) => Promise<PoolTypes.SignExecuteMethodResult<"getWordOrTemplate">>;
        flipTick: (params: PoolTypes.SignExecuteMethodParams<"flipTick">) => Promise<PoolTypes.SignExecuteMethodResult<"flipTick">>;
        nextInitializedTickWithinOneWord: (params: PoolTypes.SignExecuteMethodParams<"nextInitializedTickWithinOneWord">) => Promise<PoolTypes.SignExecuteMethodResult<"nextInitializedTickWithinOneWord">>;
        positionPath: (params: PoolTypes.SignExecuteMethodParams<"positionPath">) => Promise<PoolTypes.SignExecuteMethodResult<"positionPath">>;
        positionContractId: (params: PoolTypes.SignExecuteMethodParams<"positionContractId">) => Promise<PoolTypes.SignExecuteMethodResult<"positionContractId">>;
        configPath: (params: PoolTypes.SignExecuteMethodParams<"configPath">) => Promise<PoolTypes.SignExecuteMethodResult<"configPath">>;
        poolPath: (params: PoolTypes.SignExecuteMethodParams<"poolPath">) => Promise<PoolTypes.SignExecuteMethodResult<"poolPath">>;
        poolContractId: (params: PoolTypes.SignExecuteMethodParams<"poolContractId">) => Promise<PoolTypes.SignExecuteMethodResult<"poolContractId">>;
        checkTicks: (params: PoolTypes.SignExecuteMethodParams<"checkTicks">) => Promise<PoolTypes.SignExecuteMethodResult<"checkTicks">>;
        tickPath: (params: PoolTypes.SignExecuteMethodParams<"tickPath">) => Promise<PoolTypes.SignExecuteMethodResult<"tickPath">>;
        toTick: (params: PoolTypes.SignExecuteMethodParams<"toTick">) => Promise<PoolTypes.SignExecuteMethodResult<"toTick">>;
        getTick: (params: PoolTypes.SignExecuteMethodParams<"getTick">) => Promise<PoolTypes.SignExecuteMethodResult<"getTick">>;
        toPosition: (params: PoolTypes.SignExecuteMethodParams<"toPosition">) => Promise<PoolTypes.SignExecuteMethodResult<"toPosition">>;
        getPosition: (params: PoolTypes.SignExecuteMethodParams<"getPosition">) => Promise<PoolTypes.SignExecuteMethodResult<"getPosition">>;
        getFeeGrowthInside: (params: PoolTypes.SignExecuteMethodParams<"getFeeGrowthInside">) => Promise<PoolTypes.SignExecuteMethodResult<"getFeeGrowthInside">>;
        updatePosition: (params: PoolTypes.SignExecuteMethodParams<"updatePosition">) => Promise<PoolTypes.SignExecuteMethodResult<"updatePosition">>;
        modifyPosition: (params: PoolTypes.SignExecuteMethodParams<"modifyPosition">) => Promise<PoolTypes.SignExecuteMethodResult<"modifyPosition">>;
        mint: (params: PoolTypes.SignExecuteMethodParams<"mint">) => Promise<PoolTypes.SignExecuteMethodResult<"mint">>;
        burn: (params: PoolTypes.SignExecuteMethodParams<"burn">) => Promise<PoolTypes.SignExecuteMethodResult<"burn">>;
        collect: (params: PoolTypes.SignExecuteMethodParams<"collect">) => Promise<PoolTypes.SignExecuteMethodResult<"collect">>;
        withdraw: (params: PoolTypes.SignExecuteMethodParams<"withdraw">) => Promise<PoolTypes.SignExecuteMethodResult<"withdraw">>;
        simulateSwap: (params: PoolTypes.SignExecuteMethodParams<"simulateSwap">) => Promise<PoolTypes.SignExecuteMethodResult<"simulateSwap">>;
        swap: (params: PoolTypes.SignExecuteMethodParams<"swap">) => Promise<PoolTypes.SignExecuteMethodResult<"swap">>;
        pop: (params: PoolTypes.SignExecuteMethodParams<"pop">) => Promise<PoolTypes.SignExecuteMethodResult<"pop">>;
        swapExactOut: (params: PoolTypes.SignExecuteMethodParams<"swapExactOut">) => Promise<PoolTypes.SignExecuteMethodResult<"swapExactOut">>;
        swapExactIn: (params: PoolTypes.SignExecuteMethodParams<"swapExactIn">) => Promise<PoolTypes.SignExecuteMethodResult<"swapExactIn">>;
        getSqrtPricesX96: (params: PoolTypes.SignExecuteMethodParams<"getSqrtPricesX96">) => Promise<PoolTypes.SignExecuteMethodResult<"getSqrtPricesX96">>;
        updateReward: (params: PoolTypes.SignExecuteMethodParams<"updateReward">) => Promise<PoolTypes.SignExecuteMethodResult<"updateReward">>;
        updateRewards: (params: PoolTypes.SignExecuteMethodParams<"updateRewards">) => Promise<PoolTypes.SignExecuteMethodResult<"updateRewards">>;
        extendRewards: (params: PoolTypes.SignExecuteMethodParams<"extendRewards">) => Promise<PoolTypes.SignExecuteMethodResult<"extendRewards">>;
        setRewardParams: (params: PoolTypes.SignExecuteMethodParams<"setRewardParams">) => Promise<PoolTypes.SignExecuteMethodResult<"setRewardParams">>;
        collectProtocolFees: (params: PoolTypes.SignExecuteMethodParams<"collectProtocolFees">) => Promise<PoolTypes.SignExecuteMethodResult<"collectProtocolFees">>;
        positionInfo: (params: PoolTypes.SignExecuteMethodParams<"positionInfo">) => Promise<PoolTypes.SignExecuteMethodResult<"positionInfo">>;
        getTokenUri: (params: PoolTypes.SignExecuteMethodParams<"getTokenUri">) => Promise<PoolTypes.SignExecuteMethodResult<"getTokenUri">>;
    };
    multicall<Calls extends PoolTypes.MultiCallParams>(calls: Calls): Promise<PoolTypes.MultiCallResults<Calls>>;
    multicall<Callss extends PoolTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<PoolTypes.MulticallReturnType<Callss>>;
}

declare namespace PoolConfigTypes {
    type Fields = {
        config: Config;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        get: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<Config>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        get: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$q extends ContractFactory<PoolConfigInstance, PoolConfigTypes.Fields> {
    encodeFields(fields: PoolConfigTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    at(address: string): PoolConfigInstance;
    tests: {
        get: (params: Omit<TestContractParamsWithoutMaps<PoolConfigTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<Config>>;
    };
    stateForTest(initFields: PoolConfigTypes.Fields, asset?: Asset, address?: string): ContractState<PoolConfigTypes.Fields> | _alephium_web3.ContractStateWithMaps<PoolConfigTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const PoolConfig: Factory$q;
declare class PoolConfigInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<PoolConfigTypes.State>;
    view: {
        get: (params?: PoolConfigTypes.CallMethodParams<"get">) => Promise<PoolConfigTypes.CallMethodResult<"get">>;
    };
    transact: {
        get: (params: PoolConfigTypes.SignExecuteMethodParams<"get">) => Promise<PoolConfigTypes.SignExecuteMethodResult<"get">>;
    };
    multicall<Calls extends PoolConfigTypes.MultiCallParams>(calls: Calls): Promise<PoolConfigTypes.MultiCallResults<Calls>>;
    multicall<Callss extends PoolConfigTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<PoolConfigTypes.MulticallReturnType<Callss>>;
}

declare namespace PoolFactoryTypes {
    type Fields = {
        owner: Address;
        poolTemplate: HexString;
        positionTemplate: HexString;
        tickTemplate: HexString;
        wordTemplate: HexString;
        poolConfigTemplate: HexString;
        dexAccountTemplate: HexString;
        nextConfigIndex: bigint;
    };
    type State = ContractState<Fields>;
    type ConfigCreatedEvent = ContractEvent<{
        index: bigint;
    }>;
    type PoolCreatedEvent = ContractEvent<{
        id: HexString;
        token0: HexString;
        token1: HexString;
        configIndex: bigint;
    }>;
    type FeeTierEnabledEvent = ContractEvent<{
        fee: bigint;
        tickSpacing: bigint;
        index: bigint;
    }>;
    interface CallMethodTable {
        configPath: {
            params: CallContractParams<{
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        poolPath: {
            params: CallContractParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        poolContractId: {
            params: CallContractParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        tickSpacingToMaxLiquidityPerTick: {
            params: CallContractParams<{
                tickSpacing: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        createConfig: {
            params: CallContractParams<{
                config: Config;
            }>;
            result: CallContractResult<bigint>;
        };
        create: {
            params: CallContractParams<{
                token0: HexString;
                token1: HexString;
                configIndex: bigint;
                sqrtPriceX96: bigint;
                rewardToken: HexString;
            }>;
            result: CallContractResult<HexString>;
        };
        collectProtocolFees: {
            params: CallContractParams<{
                recipient: Address;
                configIndex: bigint;
                token0: HexString;
                token1: HexString;
            }>;
            result: CallContractResult<null>;
        };
        setRewardParams: {
            params: CallContractParams<{
                configIndex: bigint;
                token0: HexString;
                token1: HexString;
                payer: Address;
                tokenId: HexString;
                index: bigint;
                openTime: bigint;
                endTime: bigint;
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        upgrate: {
            params: CallContractParams<{
                newBytecode: HexString;
                newEncodedImmFields: HexString;
                newEncodedMutFields: HexString;
            }>;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        configPath: {
            params: SignExecuteContractMethodParams<{
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        poolPath: {
            params: SignExecuteContractMethodParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        poolContractId: {
            params: SignExecuteContractMethodParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        tickSpacingToMaxLiquidityPerTick: {
            params: SignExecuteContractMethodParams<{
                tickSpacing: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        createConfig: {
            params: SignExecuteContractMethodParams<{
                config: Config;
            }>;
            result: SignExecuteScriptTxResult;
        };
        create: {
            params: SignExecuteContractMethodParams<{
                token0: HexString;
                token1: HexString;
                configIndex: bigint;
                sqrtPriceX96: bigint;
                rewardToken: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        collectProtocolFees: {
            params: SignExecuteContractMethodParams<{
                recipient: Address;
                configIndex: bigint;
                token0: HexString;
                token1: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        setRewardParams: {
            params: SignExecuteContractMethodParams<{
                configIndex: bigint;
                token0: HexString;
                token1: HexString;
                payer: Address;
                tokenId: HexString;
                index: bigint;
                openTime: bigint;
                endTime: bigint;
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        upgrate: {
            params: SignExecuteContractMethodParams<{
                newBytecode: HexString;
                newEncodedImmFields: HexString;
                newEncodedMutFields: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$p extends ContractFactory<PoolFactoryInstance, PoolFactoryTypes.Fields> {
    encodeFields(fields: PoolFactoryTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    eventIndex: {
        ConfigCreated: number;
        PoolCreated: number;
        FeeTierEnabled: number;
    };
    consts: {
        FactoryError: {
            InvalidTokenOrder: bigint;
            UnauthorizedRewardSender: bigint;
            UnauthorizedFeeCollector: bigint;
        };
    };
    at(address: string): PoolFactoryInstance;
    tests: {
        configPath: (params: TestContractParamsWithoutMaps<PoolFactoryTypes.Fields, {
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        poolPath: (params: TestContractParamsWithoutMaps<PoolFactoryTypes.Fields, {
            factory: HexString;
            tokens: HexString;
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        poolContractId: (params: TestContractParamsWithoutMaps<PoolFactoryTypes.Fields, {
            factory: HexString;
            tokens: HexString;
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        tickSpacingToMaxLiquidityPerTick: (params: TestContractParamsWithoutMaps<PoolFactoryTypes.Fields, {
            tickSpacing: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        createConfig: (params: TestContractParamsWithoutMaps<PoolFactoryTypes.Fields, {
            config: Config;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        create: (params: TestContractParamsWithoutMaps<PoolFactoryTypes.Fields, {
            token0: HexString;
            token1: HexString;
            configIndex: bigint;
            sqrtPriceX96: bigint;
            rewardToken: HexString;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        collectProtocolFees: (params: TestContractParamsWithoutMaps<PoolFactoryTypes.Fields, {
            recipient: Address;
            configIndex: bigint;
            token0: HexString;
            token1: HexString;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        setRewardParams: (params: TestContractParamsWithoutMaps<PoolFactoryTypes.Fields, {
            configIndex: bigint;
            token0: HexString;
            token1: HexString;
            payer: Address;
            tokenId: HexString;
            index: bigint;
            openTime: bigint;
            endTime: bigint;
            amount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        upgrate: (params: TestContractParamsWithoutMaps<PoolFactoryTypes.Fields, {
            newBytecode: HexString;
            newEncodedImmFields: HexString;
            newEncodedMutFields: HexString;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
    };
    stateForTest(initFields: PoolFactoryTypes.Fields, asset?: Asset, address?: string): ContractState<PoolFactoryTypes.Fields> | _alephium_web3.ContractStateWithMaps<PoolFactoryTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const PoolFactory: Factory$p;
declare class PoolFactoryInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<PoolFactoryTypes.State>;
    getContractEventsCurrentCount(): Promise<number>;
    subscribeConfigCreatedEvent(options: EventSubscribeOptions<PoolFactoryTypes.ConfigCreatedEvent>, fromCount?: number): EventSubscription;
    subscribePoolCreatedEvent(options: EventSubscribeOptions<PoolFactoryTypes.PoolCreatedEvent>, fromCount?: number): EventSubscription;
    subscribeFeeTierEnabledEvent(options: EventSubscribeOptions<PoolFactoryTypes.FeeTierEnabledEvent>, fromCount?: number): EventSubscription;
    subscribeAllEvents(options: EventSubscribeOptions<PoolFactoryTypes.ConfigCreatedEvent | PoolFactoryTypes.PoolCreatedEvent | PoolFactoryTypes.FeeTierEnabledEvent>, fromCount?: number): EventSubscription;
    view: {
        configPath: (params: PoolFactoryTypes.CallMethodParams<"configPath">) => Promise<PoolFactoryTypes.CallMethodResult<"configPath">>;
        poolPath: (params: PoolFactoryTypes.CallMethodParams<"poolPath">) => Promise<PoolFactoryTypes.CallMethodResult<"poolPath">>;
        poolContractId: (params: PoolFactoryTypes.CallMethodParams<"poolContractId">) => Promise<PoolFactoryTypes.CallMethodResult<"poolContractId">>;
        tickSpacingToMaxLiquidityPerTick: (params: PoolFactoryTypes.CallMethodParams<"tickSpacingToMaxLiquidityPerTick">) => Promise<PoolFactoryTypes.CallMethodResult<"tickSpacingToMaxLiquidityPerTick">>;
        createConfig: (params: PoolFactoryTypes.CallMethodParams<"createConfig">) => Promise<PoolFactoryTypes.CallMethodResult<"createConfig">>;
        create: (params: PoolFactoryTypes.CallMethodParams<"create">) => Promise<PoolFactoryTypes.CallMethodResult<"create">>;
        collectProtocolFees: (params: PoolFactoryTypes.CallMethodParams<"collectProtocolFees">) => Promise<PoolFactoryTypes.CallMethodResult<"collectProtocolFees">>;
        setRewardParams: (params: PoolFactoryTypes.CallMethodParams<"setRewardParams">) => Promise<PoolFactoryTypes.CallMethodResult<"setRewardParams">>;
        upgrate: (params: PoolFactoryTypes.CallMethodParams<"upgrate">) => Promise<PoolFactoryTypes.CallMethodResult<"upgrate">>;
    };
    transact: {
        configPath: (params: PoolFactoryTypes.SignExecuteMethodParams<"configPath">) => Promise<PoolFactoryTypes.SignExecuteMethodResult<"configPath">>;
        poolPath: (params: PoolFactoryTypes.SignExecuteMethodParams<"poolPath">) => Promise<PoolFactoryTypes.SignExecuteMethodResult<"poolPath">>;
        poolContractId: (params: PoolFactoryTypes.SignExecuteMethodParams<"poolContractId">) => Promise<PoolFactoryTypes.SignExecuteMethodResult<"poolContractId">>;
        tickSpacingToMaxLiquidityPerTick: (params: PoolFactoryTypes.SignExecuteMethodParams<"tickSpacingToMaxLiquidityPerTick">) => Promise<PoolFactoryTypes.SignExecuteMethodResult<"tickSpacingToMaxLiquidityPerTick">>;
        createConfig: (params: PoolFactoryTypes.SignExecuteMethodParams<"createConfig">) => Promise<PoolFactoryTypes.SignExecuteMethodResult<"createConfig">>;
        create: (params: PoolFactoryTypes.SignExecuteMethodParams<"create">) => Promise<PoolFactoryTypes.SignExecuteMethodResult<"create">>;
        collectProtocolFees: (params: PoolFactoryTypes.SignExecuteMethodParams<"collectProtocolFees">) => Promise<PoolFactoryTypes.SignExecuteMethodResult<"collectProtocolFees">>;
        setRewardParams: (params: PoolFactoryTypes.SignExecuteMethodParams<"setRewardParams">) => Promise<PoolFactoryTypes.SignExecuteMethodResult<"setRewardParams">>;
        upgrate: (params: PoolFactoryTypes.SignExecuteMethodParams<"upgrate">) => Promise<PoolFactoryTypes.SignExecuteMethodResult<"upgrate">>;
    };
    multicall<Calls extends PoolFactoryTypes.MultiCallParams>(calls: Calls): Promise<PoolFactoryTypes.MultiCallResults<Calls>>;
    multicall<Callss extends PoolFactoryTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<PoolFactoryTypes.MulticallReturnType<Callss>>;
}

declare namespace PoolUserTypes {
    type Fields = {
        token0: HexString;
        token1: HexString;
        token2: HexString;
        pool0: HexString;
        pool1: HexString;
        pool2: HexString;
        pool3: HexString;
        factory: HexString;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        deploy: {
            params: CallContractParams<{
                counter: bigint;
                payer: Address;
                pool_: HexString;
                position_: HexString;
                tick_: HexString;
                word_: HexString;
                factory_: HexString;
                config_: HexString;
                dexAccount_: HexString;
            }>;
            result: CallContractResult<[
                HexString,
                HexString,
                HexString,
                HexString,
                HexString,
                HexString,
                HexString,
                HexString
            ]>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        deploy: {
            params: SignExecuteContractMethodParams<{
                counter: bigint;
                payer: Address;
                pool_: HexString;
                position_: HexString;
                tick_: HexString;
                word_: HexString;
                factory_: HexString;
                config_: HexString;
                dexAccount_: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$o extends ContractFactory<PoolUserInstance, PoolUserTypes.Fields> {
    encodeFields(fields: PoolUserTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    at(address: string): PoolUserInstance;
    tests: {
        deploy: (params: TestContractParamsWithoutMaps<PoolUserTypes.Fields, {
            counter: bigint;
            payer: Address;
            pool_: HexString;
            position_: HexString;
            tick_: HexString;
            word_: HexString;
            factory_: HexString;
            config_: HexString;
            dexAccount_: HexString;
        }>) => Promise<TestContractResultWithoutMaps<[HexString, HexString, HexString, HexString, HexString, HexString, HexString, HexString]>>;
    };
    stateForTest(initFields: PoolUserTypes.Fields, asset?: Asset, address?: string): ContractState<PoolUserTypes.Fields> | _alephium_web3.ContractStateWithMaps<PoolUserTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const PoolUser: Factory$o;
declare class PoolUserInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<PoolUserTypes.State>;
    view: {
        deploy: (params: PoolUserTypes.CallMethodParams<"deploy">) => Promise<PoolUserTypes.CallMethodResult<"deploy">>;
    };
    transact: {
        deploy: (params: PoolUserTypes.SignExecuteMethodParams<"deploy">) => Promise<PoolUserTypes.SignExecuteMethodResult<"deploy">>;
    };
    multicall<Calls extends PoolUserTypes.MultiCallParams>(calls: Calls): Promise<PoolUserTypes.MultiCallResults<Calls>>;
    multicall<Callss extends PoolUserTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<PoolUserTypes.MulticallReturnType<Callss>>;
}

declare namespace PositionTypes {
    type Fields = {
        parent: Address;
        nftIndex: bigint;
        liquidity: bigint;
        growthsInside: [bigint, bigint, bigint];
        tokensOwed: [bigint, bigint, bigint];
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        getTokenUri: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getCollectionIndex: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<[HexString, bigint]>;
        };
        mulDiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        mulDivRoundingUp: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        update: {
            params: CallContractParams<{
                liquidityDelta: bigint;
                growths: [bigint, bigint, bigint];
            }>;
            result: CallContractResult<[bigint, bigint, bigint]>;
        };
        deposit: {
            params: CallContractParams<{
                amount0: bigint;
                amount1: bigint;
            }>;
            result: CallContractResult<null>;
        };
        collect: {
            params: CallContractParams<{
                maxAmounts: [bigint, bigint, bigint];
            }>;
            result: CallContractResult<[bigint, bigint, bigint]>;
        };
        getState: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<[bigint, [bigint, bigint, bigint]]>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        getTokenUri: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getCollectionIndex: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        mulDiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDivRoundingUp: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        update: {
            params: SignExecuteContractMethodParams<{
                liquidityDelta: bigint;
                growths: [bigint, bigint, bigint];
            }>;
            result: SignExecuteScriptTxResult;
        };
        deposit: {
            params: SignExecuteContractMethodParams<{
                amount0: bigint;
                amount1: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        collect: {
            params: SignExecuteContractMethodParams<{
                maxAmounts: [bigint, bigint, bigint];
            }>;
            result: SignExecuteScriptTxResult;
        };
        getState: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$n extends ContractFactory<PositionInstance, PositionTypes.Fields> {
    encodeFields(fields: PositionTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        FullMathError: {
            MulDivOverflow: bigint;
        };
        PositionError: {
            NotParent: bigint;
        };
    };
    at(address: string): PositionInstance;
    tests: {
        getTokenUri: (params: Omit<TestContractParamsWithoutMaps<PositionTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<HexString>>;
        getCollectionIndex: (params: Omit<TestContractParamsWithoutMaps<PositionTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<[HexString, bigint]>>;
        mulDiv: (params: TestContractParamsWithoutMaps<PositionTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        mulDivRoundingUp: (params: TestContractParamsWithoutMaps<PositionTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        update: (params: TestContractParamsWithoutMaps<PositionTypes.Fields, {
            liquidityDelta: bigint;
            growths: [bigint, bigint, bigint];
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
        deposit: (params: TestContractParamsWithoutMaps<PositionTypes.Fields, {
            amount0: bigint;
            amount1: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        collect: (params: TestContractParamsWithoutMaps<PositionTypes.Fields, {
            maxAmounts: [bigint, bigint, bigint];
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
        getState: (params: Omit<TestContractParamsWithoutMaps<PositionTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<[bigint, [bigint, bigint, bigint]]>>;
    };
    stateForTest(initFields: PositionTypes.Fields, asset?: Asset, address?: string): ContractState<PositionTypes.Fields> | _alephium_web3.ContractStateWithMaps<PositionTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const Position: Factory$n;
declare class PositionInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<PositionTypes.State>;
    view: {
        getTokenUri: (params?: PositionTypes.CallMethodParams<"getTokenUri">) => Promise<PositionTypes.CallMethodResult<"getTokenUri">>;
        getCollectionIndex: (params?: PositionTypes.CallMethodParams<"getCollectionIndex">) => Promise<PositionTypes.CallMethodResult<"getCollectionIndex">>;
        mulDiv: (params: PositionTypes.CallMethodParams<"mulDiv">) => Promise<PositionTypes.CallMethodResult<"mulDiv">>;
        mulDivRoundingUp: (params: PositionTypes.CallMethodParams<"mulDivRoundingUp">) => Promise<PositionTypes.CallMethodResult<"mulDivRoundingUp">>;
        update: (params: PositionTypes.CallMethodParams<"update">) => Promise<PositionTypes.CallMethodResult<"update">>;
        deposit: (params: PositionTypes.CallMethodParams<"deposit">) => Promise<PositionTypes.CallMethodResult<"deposit">>;
        collect: (params: PositionTypes.CallMethodParams<"collect">) => Promise<PositionTypes.CallMethodResult<"collect">>;
        getState: (params?: PositionTypes.CallMethodParams<"getState">) => Promise<PositionTypes.CallMethodResult<"getState">>;
    };
    transact: {
        getTokenUri: (params: PositionTypes.SignExecuteMethodParams<"getTokenUri">) => Promise<PositionTypes.SignExecuteMethodResult<"getTokenUri">>;
        getCollectionIndex: (params: PositionTypes.SignExecuteMethodParams<"getCollectionIndex">) => Promise<PositionTypes.SignExecuteMethodResult<"getCollectionIndex">>;
        mulDiv: (params: PositionTypes.SignExecuteMethodParams<"mulDiv">) => Promise<PositionTypes.SignExecuteMethodResult<"mulDiv">>;
        mulDivRoundingUp: (params: PositionTypes.SignExecuteMethodParams<"mulDivRoundingUp">) => Promise<PositionTypes.SignExecuteMethodResult<"mulDivRoundingUp">>;
        update: (params: PositionTypes.SignExecuteMethodParams<"update">) => Promise<PositionTypes.SignExecuteMethodResult<"update">>;
        deposit: (params: PositionTypes.SignExecuteMethodParams<"deposit">) => Promise<PositionTypes.SignExecuteMethodResult<"deposit">>;
        collect: (params: PositionTypes.SignExecuteMethodParams<"collect">) => Promise<PositionTypes.SignExecuteMethodResult<"collect">>;
        getState: (params: PositionTypes.SignExecuteMethodParams<"getState">) => Promise<PositionTypes.SignExecuteMethodResult<"getState">>;
    };
    multicall<Calls extends PositionTypes.MultiCallParams>(calls: Calls): Promise<PositionTypes.MultiCallResults<Calls>>;
    multicall<Callss extends PositionTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<PositionTypes.MulticallReturnType<Callss>>;
}

declare namespace PositionManagerTypes {
    type Fields = {
        parent: HexString;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        addLiquidity: {
            params: CallContractParams<{
                payer: Address;
                p: ModifyLiquidityParams;
            }>;
            result: CallContractResult<[bigint, bigint, bigint, HexString]>;
        };
        getLiquidityForAmount0: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getLiquidityForAmount1: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount1: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getLiquidityForAmounts: {
            params: CallContractParams<{
                sqrtRatioX96: bigint;
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
                amount1: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getAmount0ForLiquidity: {
            params: CallContractParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidity: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        mulDiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        mulDivRoundingUp: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        configPath: {
            params: CallContractParams<{
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        poolPath: {
            params: CallContractParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        poolContractId: {
            params: CallContractParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        positionPath: {
            params: CallContractParams<{
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        positionContractId: {
            params: CallContractParams<{
                pool: HexString;
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        increaseLiquidity: {
            params: CallContractParams<{
                payer: Address;
                p: ModifyLiquidityParams;
            }>;
            result: CallContractResult<null>;
        };
        decreaseLiquidity: {
            params: CallContractParams<{
                operator: Address;
                liquidity: bigint;
                p: DecreaseLiquidityParams;
            }>;
            result: CallContractResult<null>;
        };
        collect: {
            params: CallContractParams<{
                operator: Address;
                liquidity: bigint;
                p: CollectParams;
            }>;
            result: CallContractResult<null>;
        };
        getSqrtPricesX96: {
            params: CallContractParams<{
                pool: HexString;
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<[bigint, bigint, bigint, bigint]>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        addLiquidity: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                p: ModifyLiquidityParams;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getLiquidityForAmount0: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getLiquidityForAmount1: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount1: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getLiquidityForAmounts: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioX96: bigint;
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                amount0: bigint;
                amount1: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getAmount0ForLiquidity: {
            params: SignExecuteContractMethodParams<{
                sqrtRatioAX96: bigint;
                sqrtRatioBX96: bigint;
                liquidity: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDivRoundingUp: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        configPath: {
            params: SignExecuteContractMethodParams<{
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        poolPath: {
            params: SignExecuteContractMethodParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        poolContractId: {
            params: SignExecuteContractMethodParams<{
                factory: HexString;
                tokens: HexString;
                configIndex_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        positionPath: {
            params: SignExecuteContractMethodParams<{
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        positionContractId: {
            params: SignExecuteContractMethodParams<{
                pool: HexString;
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        increaseLiquidity: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                p: ModifyLiquidityParams;
            }>;
            result: SignExecuteScriptTxResult;
        };
        decreaseLiquidity: {
            params: SignExecuteContractMethodParams<{
                operator: Address;
                liquidity: bigint;
                p: DecreaseLiquidityParams;
            }>;
            result: SignExecuteScriptTxResult;
        };
        collect: {
            params: SignExecuteContractMethodParams<{
                operator: Address;
                liquidity: bigint;
                p: CollectParams;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getSqrtPricesX96: {
            params: SignExecuteContractMethodParams<{
                pool: HexString;
                owner: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$m extends ContractFactory<PositionManagerInstance, PositionManagerTypes.Fields> {
    encodeFields(fields: PositionManagerTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        LiquidityManagmentError: {
            MintSlippage: bigint;
            BurnSlippage: bigint;
        };
        FullMathError: {
            MulDivOverflow: bigint;
        };
        PathPrefixes: {
            Tick: bigint;
            Position: bigint;
            Word: bigint;
        };
    };
    at(address: string): PositionManagerInstance;
    tests: {
        addLiquidity: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            payer: Address;
            p: ModifyLiquidityParams;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint, HexString]>>;
        getLiquidityForAmount0: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            amount0: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getLiquidityForAmount1: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            amount1: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getLiquidityForAmounts: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            sqrtRatioX96: bigint;
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            amount0: bigint;
            amount1: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getAmount0ForLiquidity: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            sqrtRatioAX96: bigint;
            sqrtRatioBX96: bigint;
            liquidity: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        mulDiv: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        mulDivRoundingUp: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        configPath: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        poolPath: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            factory: HexString;
            tokens: HexString;
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        poolContractId: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            factory: HexString;
            tokens: HexString;
            configIndex_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        positionPath: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            o: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        positionContractId: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            pool: HexString;
            o: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        increaseLiquidity: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            payer: Address;
            p: ModifyLiquidityParams;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        decreaseLiquidity: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            operator: Address;
            liquidity: bigint;
            p: DecreaseLiquidityParams;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        collect: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            operator: Address;
            liquidity: bigint;
            p: CollectParams;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        getSqrtPricesX96: (params: TestContractParamsWithoutMaps<PositionManagerTypes.Fields, {
            pool: HexString;
            owner: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint, bigint]>>;
    };
    stateForTest(initFields: PositionManagerTypes.Fields, asset?: Asset, address?: string): ContractState<PositionManagerTypes.Fields> | _alephium_web3.ContractStateWithMaps<PositionManagerTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const PositionManager: Factory$m;
declare class PositionManagerInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<PositionManagerTypes.State>;
    view: {
        addLiquidity: (params: PositionManagerTypes.CallMethodParams<"addLiquidity">) => Promise<PositionManagerTypes.CallMethodResult<"addLiquidity">>;
        getLiquidityForAmount0: (params: PositionManagerTypes.CallMethodParams<"getLiquidityForAmount0">) => Promise<PositionManagerTypes.CallMethodResult<"getLiquidityForAmount0">>;
        getLiquidityForAmount1: (params: PositionManagerTypes.CallMethodParams<"getLiquidityForAmount1">) => Promise<PositionManagerTypes.CallMethodResult<"getLiquidityForAmount1">>;
        getLiquidityForAmounts: (params: PositionManagerTypes.CallMethodParams<"getLiquidityForAmounts">) => Promise<PositionManagerTypes.CallMethodResult<"getLiquidityForAmounts">>;
        getAmount0ForLiquidity: (params: PositionManagerTypes.CallMethodParams<"getAmount0ForLiquidity">) => Promise<PositionManagerTypes.CallMethodResult<"getAmount0ForLiquidity">>;
        mulDiv: (params: PositionManagerTypes.CallMethodParams<"mulDiv">) => Promise<PositionManagerTypes.CallMethodResult<"mulDiv">>;
        mulDivRoundingUp: (params: PositionManagerTypes.CallMethodParams<"mulDivRoundingUp">) => Promise<PositionManagerTypes.CallMethodResult<"mulDivRoundingUp">>;
        configPath: (params: PositionManagerTypes.CallMethodParams<"configPath">) => Promise<PositionManagerTypes.CallMethodResult<"configPath">>;
        poolPath: (params: PositionManagerTypes.CallMethodParams<"poolPath">) => Promise<PositionManagerTypes.CallMethodResult<"poolPath">>;
        poolContractId: (params: PositionManagerTypes.CallMethodParams<"poolContractId">) => Promise<PositionManagerTypes.CallMethodResult<"poolContractId">>;
        positionPath: (params: PositionManagerTypes.CallMethodParams<"positionPath">) => Promise<PositionManagerTypes.CallMethodResult<"positionPath">>;
        positionContractId: (params: PositionManagerTypes.CallMethodParams<"positionContractId">) => Promise<PositionManagerTypes.CallMethodResult<"positionContractId">>;
        increaseLiquidity: (params: PositionManagerTypes.CallMethodParams<"increaseLiquidity">) => Promise<PositionManagerTypes.CallMethodResult<"increaseLiquidity">>;
        decreaseLiquidity: (params: PositionManagerTypes.CallMethodParams<"decreaseLiquidity">) => Promise<PositionManagerTypes.CallMethodResult<"decreaseLiquidity">>;
        collect: (params: PositionManagerTypes.CallMethodParams<"collect">) => Promise<PositionManagerTypes.CallMethodResult<"collect">>;
        getSqrtPricesX96: (params: PositionManagerTypes.CallMethodParams<"getSqrtPricesX96">) => Promise<PositionManagerTypes.CallMethodResult<"getSqrtPricesX96">>;
    };
    transact: {
        addLiquidity: (params: PositionManagerTypes.SignExecuteMethodParams<"addLiquidity">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"addLiquidity">>;
        getLiquidityForAmount0: (params: PositionManagerTypes.SignExecuteMethodParams<"getLiquidityForAmount0">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"getLiquidityForAmount0">>;
        getLiquidityForAmount1: (params: PositionManagerTypes.SignExecuteMethodParams<"getLiquidityForAmount1">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"getLiquidityForAmount1">>;
        getLiquidityForAmounts: (params: PositionManagerTypes.SignExecuteMethodParams<"getLiquidityForAmounts">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"getLiquidityForAmounts">>;
        getAmount0ForLiquidity: (params: PositionManagerTypes.SignExecuteMethodParams<"getAmount0ForLiquidity">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"getAmount0ForLiquidity">>;
        mulDiv: (params: PositionManagerTypes.SignExecuteMethodParams<"mulDiv">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"mulDiv">>;
        mulDivRoundingUp: (params: PositionManagerTypes.SignExecuteMethodParams<"mulDivRoundingUp">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"mulDivRoundingUp">>;
        configPath: (params: PositionManagerTypes.SignExecuteMethodParams<"configPath">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"configPath">>;
        poolPath: (params: PositionManagerTypes.SignExecuteMethodParams<"poolPath">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"poolPath">>;
        poolContractId: (params: PositionManagerTypes.SignExecuteMethodParams<"poolContractId">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"poolContractId">>;
        positionPath: (params: PositionManagerTypes.SignExecuteMethodParams<"positionPath">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"positionPath">>;
        positionContractId: (params: PositionManagerTypes.SignExecuteMethodParams<"positionContractId">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"positionContractId">>;
        increaseLiquidity: (params: PositionManagerTypes.SignExecuteMethodParams<"increaseLiquidity">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"increaseLiquidity">>;
        decreaseLiquidity: (params: PositionManagerTypes.SignExecuteMethodParams<"decreaseLiquidity">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"decreaseLiquidity">>;
        collect: (params: PositionManagerTypes.SignExecuteMethodParams<"collect">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"collect">>;
        getSqrtPricesX96: (params: PositionManagerTypes.SignExecuteMethodParams<"getSqrtPricesX96">) => Promise<PositionManagerTypes.SignExecuteMethodResult<"getSqrtPricesX96">>;
    };
    multicall<Calls extends PositionManagerTypes.MultiCallParams>(calls: Calls): Promise<PositionManagerTypes.MultiCallResults<Calls>>;
    multicall<Callss extends PositionManagerTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<PositionManagerTypes.MulticallReturnType<Callss>>;
}

declare namespace TestTokenTypes$1 {
    type Fields = {
        symbol: HexString;
        name: HexString;
        decimals: bigint;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        getSymbol: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getName: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getDecimals: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        getTotalSupply: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        getSymbol: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getName: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getDecimals: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getTotalSupply: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$l extends ContractFactory<TestTokenInstance$1, TestTokenTypes$1.Fields> {
    encodeFields(fields: TestTokenTypes$1.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    at(address: string): TestTokenInstance$1;
    tests: {
        getSymbol: (params: Omit<TestContractParamsWithoutMaps<TestTokenTypes$1.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<HexString>>;
        getName: (params: Omit<TestContractParamsWithoutMaps<TestTokenTypes$1.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<HexString>>;
        getDecimals: (params: Omit<TestContractParamsWithoutMaps<TestTokenTypes$1.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        getTotalSupply: (params: Omit<TestContractParamsWithoutMaps<TestTokenTypes$1.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
    };
    stateForTest(initFields: TestTokenTypes$1.Fields, asset?: Asset, address?: string): ContractState<TestTokenTypes$1.Fields> | _alephium_web3.ContractStateWithMaps<TestTokenTypes$1.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const TestToken$1: Factory$l;
declare class TestTokenInstance$1 extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<TestTokenTypes$1.State>;
    view: {
        getSymbol: (params?: TestTokenTypes$1.CallMethodParams<"getSymbol">) => Promise<TestTokenTypes$1.CallMethodResult<"getSymbol">>;
        getName: (params?: TestTokenTypes$1.CallMethodParams<"getName">) => Promise<TestTokenTypes$1.CallMethodResult<"getName">>;
        getDecimals: (params?: TestTokenTypes$1.CallMethodParams<"getDecimals">) => Promise<TestTokenTypes$1.CallMethodResult<"getDecimals">>;
        getTotalSupply: (params?: TestTokenTypes$1.CallMethodParams<"getTotalSupply">) => Promise<TestTokenTypes$1.CallMethodResult<"getTotalSupply">>;
    };
    transact: {
        getSymbol: (params: TestTokenTypes$1.SignExecuteMethodParams<"getSymbol">) => Promise<TestTokenTypes$1.SignExecuteMethodResult<"getSymbol">>;
        getName: (params: TestTokenTypes$1.SignExecuteMethodParams<"getName">) => Promise<TestTokenTypes$1.SignExecuteMethodResult<"getName">>;
        getDecimals: (params: TestTokenTypes$1.SignExecuteMethodParams<"getDecimals">) => Promise<TestTokenTypes$1.SignExecuteMethodResult<"getDecimals">>;
        getTotalSupply: (params: TestTokenTypes$1.SignExecuteMethodParams<"getTotalSupply">) => Promise<TestTokenTypes$1.SignExecuteMethodResult<"getTotalSupply">>;
    };
    multicall<Calls extends TestTokenTypes$1.MultiCallParams>(calls: Calls): Promise<TestTokenTypes$1.MultiCallResults<Calls>>;
    multicall<Callss extends TestTokenTypes$1.MultiCallParams[]>(callss: Narrow<Callss>): Promise<TestTokenTypes$1.MulticallReturnType<Callss>>;
}

declare namespace TickTypes {
    type Fields = {
        parent: Address;
        tick: bigint;
        liquidityGross: bigint;
        liquidityNet: bigint;
        feeGrowthsOutside: [bigint, bigint, bigint];
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        update: {
            params: CallContractParams<{
                maxLiquidity: bigint;
                liquidityDelta: bigint;
                upper: boolean;
            }>;
            result: CallContractResult<boolean>;
        };
        feeGrowthBelow: {
            params: CallContractParams<{
                tickCurrent: bigint;
                globalGrowths: [bigint, bigint, bigint];
            }>;
            result: CallContractResult<[bigint, bigint, bigint]>;
        };
        feeGrowthAbove: {
            params: CallContractParams<{
                tickCurrent: bigint;
                globalGrowths: [bigint, bigint, bigint];
            }>;
            result: CallContractResult<[bigint, bigint, bigint]>;
        };
        clear: {
            params: CallContractParams<{
                payer: Address;
            }>;
            result: CallContractResult<null>;
        };
        cross: {
            params: CallContractParams<{
                globalGrowths: [bigint, bigint, bigint];
                zeroForOne: boolean;
                feeGrowthGlobalX128: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getLiquidityNet: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        update: {
            params: SignExecuteContractMethodParams<{
                maxLiquidity: bigint;
                liquidityDelta: bigint;
                upper: boolean;
            }>;
            result: SignExecuteScriptTxResult;
        };
        feeGrowthBelow: {
            params: SignExecuteContractMethodParams<{
                tickCurrent: bigint;
                globalGrowths: [bigint, bigint, bigint];
            }>;
            result: SignExecuteScriptTxResult;
        };
        feeGrowthAbove: {
            params: SignExecuteContractMethodParams<{
                tickCurrent: bigint;
                globalGrowths: [bigint, bigint, bigint];
            }>;
            result: SignExecuteScriptTxResult;
        };
        clear: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        cross: {
            params: SignExecuteContractMethodParams<{
                globalGrowths: [bigint, bigint, bigint];
                zeroForOne: boolean;
                feeGrowthGlobalX128: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getLiquidityNet: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$k extends ContractFactory<TickInstance, TickTypes.Fields> {
    encodeFields(fields: TickTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        TickError: {
            NotParent: bigint;
            LO: bigint;
            LS: bigint;
        };
    };
    at(address: string): TickInstance;
    tests: {
        update: (params: TestContractParamsWithoutMaps<TickTypes.Fields, {
            maxLiquidity: bigint;
            liquidityDelta: bigint;
            upper: boolean;
        }>) => Promise<TestContractResultWithoutMaps<boolean>>;
        feeGrowthBelow: (params: TestContractParamsWithoutMaps<TickTypes.Fields, {
            tickCurrent: bigint;
            globalGrowths: [bigint, bigint, bigint];
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
        feeGrowthAbove: (params: TestContractParamsWithoutMaps<TickTypes.Fields, {
            tickCurrent: bigint;
            globalGrowths: [bigint, bigint, bigint];
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
        clear: (params: TestContractParamsWithoutMaps<TickTypes.Fields, {
            payer: Address;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        cross: (params: TestContractParamsWithoutMaps<TickTypes.Fields, {
            globalGrowths: [bigint, bigint, bigint];
            zeroForOne: boolean;
            feeGrowthGlobalX128: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getLiquidityNet: (params: Omit<TestContractParamsWithoutMaps<TickTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
    };
    stateForTest(initFields: TickTypes.Fields, asset?: Asset, address?: string): ContractState<TickTypes.Fields> | _alephium_web3.ContractStateWithMaps<TickTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const Tick: Factory$k;
declare class TickInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<TickTypes.State>;
    view: {
        update: (params: TickTypes.CallMethodParams<"update">) => Promise<TickTypes.CallMethodResult<"update">>;
        feeGrowthBelow: (params: TickTypes.CallMethodParams<"feeGrowthBelow">) => Promise<TickTypes.CallMethodResult<"feeGrowthBelow">>;
        feeGrowthAbove: (params: TickTypes.CallMethodParams<"feeGrowthAbove">) => Promise<TickTypes.CallMethodResult<"feeGrowthAbove">>;
        clear: (params: TickTypes.CallMethodParams<"clear">) => Promise<TickTypes.CallMethodResult<"clear">>;
        cross: (params: TickTypes.CallMethodParams<"cross">) => Promise<TickTypes.CallMethodResult<"cross">>;
        getLiquidityNet: (params?: TickTypes.CallMethodParams<"getLiquidityNet">) => Promise<TickTypes.CallMethodResult<"getLiquidityNet">>;
    };
    transact: {
        update: (params: TickTypes.SignExecuteMethodParams<"update">) => Promise<TickTypes.SignExecuteMethodResult<"update">>;
        feeGrowthBelow: (params: TickTypes.SignExecuteMethodParams<"feeGrowthBelow">) => Promise<TickTypes.SignExecuteMethodResult<"feeGrowthBelow">>;
        feeGrowthAbove: (params: TickTypes.SignExecuteMethodParams<"feeGrowthAbove">) => Promise<TickTypes.SignExecuteMethodResult<"feeGrowthAbove">>;
        clear: (params: TickTypes.SignExecuteMethodParams<"clear">) => Promise<TickTypes.SignExecuteMethodResult<"clear">>;
        cross: (params: TickTypes.SignExecuteMethodParams<"cross">) => Promise<TickTypes.SignExecuteMethodResult<"cross">>;
        getLiquidityNet: (params: TickTypes.SignExecuteMethodParams<"getLiquidityNet">) => Promise<TickTypes.SignExecuteMethodResult<"getLiquidityNet">>;
    };
    multicall<Calls extends TickTypes.MultiCallParams>(calls: Calls): Promise<TickTypes.MultiCallResults<Calls>>;
    multicall<Callss extends TickTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<TickTypes.MulticallReturnType<Callss>>;
}

declare namespace TickBitmapTestTypes {
    type Fields = {
        wordTemplate: HexString;
        tickSpacing: bigint;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        wordPath: {
            params: CallContractParams<{
                compressed: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        getWord: {
            params: CallContractParams<{
                compressed: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        getWordOrTemplate: {
            params: CallContractParams<{
                compressed: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        flipTick: {
            params: CallContractParams<{
                tick: bigint;
            }>;
            result: CallContractResult<null>;
        };
        nextInitializedTickWithinOneWord: {
            params: CallContractParams<{
                tick: bigint;
                zeroForOne: boolean;
            }>;
            result: CallContractResult<[bigint, boolean]>;
        };
        positionPath: {
            params: CallContractParams<{
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        positionContractId: {
            params: CallContractParams<{
                pool: HexString;
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        deploy: {
            params: CallContractParams<{
                payer: Address;
                word: HexString;
                ts: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        flipTick_: {
            params: CallContractParams<{
                tick: bigint;
            }>;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        wordPath: {
            params: SignExecuteContractMethodParams<{
                compressed: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getWord: {
            params: SignExecuteContractMethodParams<{
                compressed: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getWordOrTemplate: {
            params: SignExecuteContractMethodParams<{
                compressed: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        flipTick: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        nextInitializedTickWithinOneWord: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
                zeroForOne: boolean;
            }>;
            result: SignExecuteScriptTxResult;
        };
        positionPath: {
            params: SignExecuteContractMethodParams<{
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        positionContractId: {
            params: SignExecuteContractMethodParams<{
                pool: HexString;
                o: Address;
                tickLower: bigint;
                tickUpper: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        deploy: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                word: HexString;
                ts: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        flipTick_: {
            params: SignExecuteContractMethodParams<{
                tick: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$j extends ContractFactory<TickBitmapTestInstance, TickBitmapTestTypes.Fields> {
    encodeFields(fields: TickBitmapTestTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        TickBitmapError: {
            TickNotAligned: bigint;
        };
        PathPrefixes: {
            Tick: bigint;
            Position: bigint;
            Word: bigint;
        };
    };
    at(address: string): TickBitmapTestInstance;
    tests: {
        wordPath: (params: TestContractParamsWithoutMaps<TickBitmapTestTypes.Fields, {
            compressed: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        getWord: (params: TestContractParamsWithoutMaps<TickBitmapTestTypes.Fields, {
            compressed: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        getWordOrTemplate: (params: TestContractParamsWithoutMaps<TickBitmapTestTypes.Fields, {
            compressed: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        flipTick: (params: TestContractParamsWithoutMaps<TickBitmapTestTypes.Fields, {
            tick: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        nextInitializedTickWithinOneWord: (params: TestContractParamsWithoutMaps<TickBitmapTestTypes.Fields, {
            tick: bigint;
            zeroForOne: boolean;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, boolean]>>;
        positionPath: (params: TestContractParamsWithoutMaps<TickBitmapTestTypes.Fields, {
            o: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        positionContractId: (params: TestContractParamsWithoutMaps<TickBitmapTestTypes.Fields, {
            pool: HexString;
            o: Address;
            tickLower: bigint;
            tickUpper: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        deploy: (params: TestContractParamsWithoutMaps<TickBitmapTestTypes.Fields, {
            payer: Address;
            word: HexString;
            ts: bigint;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        flipTick_: (params: TestContractParamsWithoutMaps<TickBitmapTestTypes.Fields, {
            tick: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
    };
    stateForTest(initFields: TickBitmapTestTypes.Fields, asset?: Asset, address?: string): ContractState<TickBitmapTestTypes.Fields> | _alephium_web3.ContractStateWithMaps<TickBitmapTestTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const TickBitmapTest: Factory$j;
declare class TickBitmapTestInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<TickBitmapTestTypes.State>;
    view: {
        wordPath: (params: TickBitmapTestTypes.CallMethodParams<"wordPath">) => Promise<TickBitmapTestTypes.CallMethodResult<"wordPath">>;
        getWord: (params: TickBitmapTestTypes.CallMethodParams<"getWord">) => Promise<TickBitmapTestTypes.CallMethodResult<"getWord">>;
        getWordOrTemplate: (params: TickBitmapTestTypes.CallMethodParams<"getWordOrTemplate">) => Promise<TickBitmapTestTypes.CallMethodResult<"getWordOrTemplate">>;
        flipTick: (params: TickBitmapTestTypes.CallMethodParams<"flipTick">) => Promise<TickBitmapTestTypes.CallMethodResult<"flipTick">>;
        nextInitializedTickWithinOneWord: (params: TickBitmapTestTypes.CallMethodParams<"nextInitializedTickWithinOneWord">) => Promise<TickBitmapTestTypes.CallMethodResult<"nextInitializedTickWithinOneWord">>;
        positionPath: (params: TickBitmapTestTypes.CallMethodParams<"positionPath">) => Promise<TickBitmapTestTypes.CallMethodResult<"positionPath">>;
        positionContractId: (params: TickBitmapTestTypes.CallMethodParams<"positionContractId">) => Promise<TickBitmapTestTypes.CallMethodResult<"positionContractId">>;
        deploy: (params: TickBitmapTestTypes.CallMethodParams<"deploy">) => Promise<TickBitmapTestTypes.CallMethodResult<"deploy">>;
        flipTick_: (params: TickBitmapTestTypes.CallMethodParams<"flipTick_">) => Promise<TickBitmapTestTypes.CallMethodResult<"flipTick_">>;
    };
    transact: {
        wordPath: (params: TickBitmapTestTypes.SignExecuteMethodParams<"wordPath">) => Promise<TickBitmapTestTypes.SignExecuteMethodResult<"wordPath">>;
        getWord: (params: TickBitmapTestTypes.SignExecuteMethodParams<"getWord">) => Promise<TickBitmapTestTypes.SignExecuteMethodResult<"getWord">>;
        getWordOrTemplate: (params: TickBitmapTestTypes.SignExecuteMethodParams<"getWordOrTemplate">) => Promise<TickBitmapTestTypes.SignExecuteMethodResult<"getWordOrTemplate">>;
        flipTick: (params: TickBitmapTestTypes.SignExecuteMethodParams<"flipTick">) => Promise<TickBitmapTestTypes.SignExecuteMethodResult<"flipTick">>;
        nextInitializedTickWithinOneWord: (params: TickBitmapTestTypes.SignExecuteMethodParams<"nextInitializedTickWithinOneWord">) => Promise<TickBitmapTestTypes.SignExecuteMethodResult<"nextInitializedTickWithinOneWord">>;
        positionPath: (params: TickBitmapTestTypes.SignExecuteMethodParams<"positionPath">) => Promise<TickBitmapTestTypes.SignExecuteMethodResult<"positionPath">>;
        positionContractId: (params: TickBitmapTestTypes.SignExecuteMethodParams<"positionContractId">) => Promise<TickBitmapTestTypes.SignExecuteMethodResult<"positionContractId">>;
        deploy: (params: TickBitmapTestTypes.SignExecuteMethodParams<"deploy">) => Promise<TickBitmapTestTypes.SignExecuteMethodResult<"deploy">>;
        flipTick_: (params: TickBitmapTestTypes.SignExecuteMethodParams<"flipTick_">) => Promise<TickBitmapTestTypes.SignExecuteMethodResult<"flipTick_">>;
    };
    multicall<Calls extends TickBitmapTestTypes.MultiCallParams>(calls: Calls): Promise<TickBitmapTestTypes.MultiCallResults<Calls>>;
    multicall<Callss extends TickBitmapTestTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<TickBitmapTestTypes.MulticallReturnType<Callss>>;
}

declare function getAllContracts$2(): ContractFactory<any>[];
declare function registerContract$2(factory: ContractFactory<any>): void;
declare function getContractByCodeHash$2(codeHash: string): Contract;

declare const CreateConfig: ExecutableScript<{
    factory: HexString;
    tickSpacing: bigint;
    fee: bigint;
    feeProtocol: bigint;
    configIndex: bigint;
}, null>;
declare const CreateLiquidPool: ExecutableScript<{
    factory: HexString;
    token0: HexString;
    token1: HexString;
    configIndex: bigint;
    sqrtPriceX96: bigint;
    rewardToken: HexString;
    tickLower: bigint;
    tickUpper: bigint;
    liquidity: bigint;
    amount0: bigint;
    amount1: bigint;
}, null>;
declare const PoolRouterDemo: ExecutableScript<{
    pool_: HexString;
    position_: HexString;
    tick_: HexString;
    word_: HexString;
    factory_: HexString;
    user_: HexString;
    config_: HexString;
    dexAccount_: HexString;
    counter: bigint;
}, null>;
declare const SwapWithoutAccount: ExecutableScript<{
    dexAccount: HexString;
    pool: HexString;
    tokenIn: HexString;
    tokenOut: HexString;
    zeroForOne: boolean;
    amountSpecified: bigint;
    sqrtPriceLimitX96: bigint;
    data: HexString;
}, null>;

declare const scripts$1_CreateConfig: typeof CreateConfig;
declare const scripts$1_CreateLiquidPool: typeof CreateLiquidPool;
declare const scripts$1_PoolRouterDemo: typeof PoolRouterDemo;
declare const scripts$1_SwapWithoutAccount: typeof SwapWithoutAccount;
declare namespace scripts$1 {
  export { scripts$1_CreateConfig as CreateConfig, scripts$1_CreateLiquidPool as CreateLiquidPool, scripts$1_PoolRouterDemo as PoolRouterDemo, scripts$1_SwapWithoutAccount as SwapWithoutAccount };
}

declare const index$2_BitmapWord: typeof BitmapWord;
declare const index$2_BitmapWordDeployer: typeof BitmapWordDeployer;
type index$2_BitmapWordDeployerInstance = BitmapWordDeployerInstance;
declare const index$2_BitmapWordDeployerInstance: typeof BitmapWordDeployerInstance;
declare const index$2_BitmapWordDeployerTypes: typeof BitmapWordDeployerTypes;
type index$2_BitmapWordInstance = BitmapWordInstance;
declare const index$2_BitmapWordInstance: typeof BitmapWordInstance;
declare const index$2_BitmapWordTypes: typeof BitmapWordTypes;
declare const index$2_CreateConfig: typeof CreateConfig;
declare const index$2_CreateLiquidPool: typeof CreateLiquidPool;
declare const index$2_LiquidityAmountsTest: typeof LiquidityAmountsTest;
type index$2_LiquidityAmountsTestInstance = LiquidityAmountsTestInstance;
declare const index$2_LiquidityAmountsTestInstance: typeof LiquidityAmountsTestInstance;
declare const index$2_LiquidityAmountsTestTypes: typeof LiquidityAmountsTestTypes;
declare const index$2_LiquidityManagmentTest: typeof LiquidityManagmentTest;
type index$2_LiquidityManagmentTestInstance = LiquidityManagmentTestInstance;
declare const index$2_LiquidityManagmentTestInstance: typeof LiquidityManagmentTestInstance;
declare const index$2_LiquidityManagmentTestTypes: typeof LiquidityManagmentTestTypes;
declare const index$2_Pool: typeof Pool;
declare const index$2_PoolConfig: typeof PoolConfig;
type index$2_PoolConfigInstance = PoolConfigInstance;
declare const index$2_PoolConfigInstance: typeof PoolConfigInstance;
declare const index$2_PoolConfigTypes: typeof PoolConfigTypes;
declare const index$2_PoolFactory: typeof PoolFactory;
type index$2_PoolFactoryInstance = PoolFactoryInstance;
declare const index$2_PoolFactoryInstance: typeof PoolFactoryInstance;
declare const index$2_PoolFactoryTypes: typeof PoolFactoryTypes;
type index$2_PoolInstance = PoolInstance;
declare const index$2_PoolInstance: typeof PoolInstance;
declare const index$2_PoolRouterDemo: typeof PoolRouterDemo;
declare const index$2_PoolTypes: typeof PoolTypes;
declare const index$2_PoolUser: typeof PoolUser;
type index$2_PoolUserInstance = PoolUserInstance;
declare const index$2_PoolUserInstance: typeof PoolUserInstance;
declare const index$2_PoolUserTypes: typeof PoolUserTypes;
declare const index$2_Position: typeof Position;
type index$2_PositionInstance = PositionInstance;
declare const index$2_PositionInstance: typeof PositionInstance;
declare const index$2_PositionManager: typeof PositionManager;
type index$2_PositionManagerInstance = PositionManagerInstance;
declare const index$2_PositionManagerInstance: typeof PositionManagerInstance;
declare const index$2_PositionManagerTypes: typeof PositionManagerTypes;
declare const index$2_PositionTypes: typeof PositionTypes;
declare const index$2_SwapWithoutAccount: typeof SwapWithoutAccount;
declare const index$2_Tick: typeof Tick;
declare const index$2_TickBitmapTest: typeof TickBitmapTest;
type index$2_TickBitmapTestInstance = TickBitmapTestInstance;
declare const index$2_TickBitmapTestInstance: typeof TickBitmapTestInstance;
declare const index$2_TickBitmapTestTypes: typeof TickBitmapTestTypes;
type index$2_TickInstance = TickInstance;
declare const index$2_TickInstance: typeof TickInstance;
declare const index$2_TickTypes: typeof TickTypes;
declare namespace index$2 {
  export { index$2_BitmapWord as BitmapWord, index$2_BitmapWordDeployer as BitmapWordDeployer, index$2_BitmapWordDeployerInstance as BitmapWordDeployerInstance, index$2_BitmapWordDeployerTypes as BitmapWordDeployerTypes, index$2_BitmapWordInstance as BitmapWordInstance, index$2_BitmapWordTypes as BitmapWordTypes, index$2_CreateConfig as CreateConfig, index$2_CreateLiquidPool as CreateLiquidPool, DexAccount$1 as DexAccount, DexAccountInstance$1 as DexAccountInstance, DexAccountTypes$1 as DexAccountTypes, index$2_LiquidityAmountsTest as LiquidityAmountsTest, index$2_LiquidityAmountsTestInstance as LiquidityAmountsTestInstance, index$2_LiquidityAmountsTestTypes as LiquidityAmountsTestTypes, index$2_LiquidityManagmentTest as LiquidityManagmentTest, index$2_LiquidityManagmentTestInstance as LiquidityManagmentTestInstance, index$2_LiquidityManagmentTestTypes as LiquidityManagmentTestTypes, index$2_Pool as Pool, index$2_PoolConfig as PoolConfig, index$2_PoolConfigInstance as PoolConfigInstance, index$2_PoolConfigTypes as PoolConfigTypes, index$2_PoolFactory as PoolFactory, index$2_PoolFactoryInstance as PoolFactoryInstance, index$2_PoolFactoryTypes as PoolFactoryTypes, index$2_PoolInstance as PoolInstance, index$2_PoolRouterDemo as PoolRouterDemo, index$2_PoolTypes as PoolTypes, index$2_PoolUser as PoolUser, index$2_PoolUserInstance as PoolUserInstance, index$2_PoolUserTypes as PoolUserTypes, index$2_Position as Position, index$2_PositionInstance as PositionInstance, index$2_PositionManager as PositionManager, index$2_PositionManagerInstance as PositionManagerInstance, index$2_PositionManagerTypes as PositionManagerTypes, index$2_PositionTypes as PositionTypes, index$2_SwapWithoutAccount as SwapWithoutAccount, TestToken$1 as TestToken, TestTokenInstance$1 as TestTokenInstance, TestTokenTypes$1 as TestTokenTypes, index$2_Tick as Tick, index$2_TickBitmapTest as TickBitmapTest, index$2_TickBitmapTestInstance as TickBitmapTestInstance, index$2_TickBitmapTestTypes as TickBitmapTestTypes, index$2_TickInstance as TickInstance, index$2_TickTypes as TickTypes, getAllContracts$2 as getAllContracts, getContractByCodeHash$2 as getContractByCodeHash, registerContract$2 as registerContract };
}

declare class ClmmModule extends ModuleBase {
    private config;
    private configsByIndex;
    constructor(scope: Zeta);
    setConfig(config: ClmmConfig): void;
    getClmmConfig(): ClmmConfig;
    getPoolConfigId(configIndex: bigint): string;
    getAllPoolConfigs(): Promise<ClmmPoolConfig[]>;
    getPoolConfig(configIndex: bigint): Promise<ClmmPoolConfig | undefined>;
    private fetchConfigFromChain;
    getPoolState(poolId: string): Promise<ClmmPoolContractState>;
    getPoolTokenBalances(poolId: string): Promise<{
        token0Balance: bigint;
        token1Balance: bigint;
    }>;
    getPoolId(tokenA: string, tokenB: string, configIndex: bigint): string;
    getPositionId(poolId: string, owner: string, tickLower: bigint, tickUpper: bigint): string;
    getPoolAddress(tokenA: string, tokenB: string, configIndex: bigint): string;
    getPool(tokenA: string, tokenB: string, configIndex: bigint): PoolInstance;
    poolExists(tokenA: string, tokenB: string, configIndex: bigint): Promise<boolean>;
    createPool(configIndex: bigint, token0: string, token1: string, rewardToken: string, tick: bigint, amount0: bigint, amount1: bigint, tickLower: bigint, tickUpper: bigint, dustAmount?: bigint): Promise<{
        poolAddress: string;
        result: SignExecuteScriptTxResult;
    }>;
    addLiquidity(p: AddLiquidity$1): Promise<{
        positionId: string;
        result: SignExecuteScriptTxResult;
    }>;
    removeLiquidity(p: RemoveLiquidity$1): Promise<{
        positionId: string;
        result: SignExecuteScriptTxResult;
    }>;
    positionInfo({ poolId, ...args }: PositionPath): Promise<ClmmPositionInfo>;
    collectTokens(p: CollectTokens): Promise<{
        positionId: string;
        result: SignExecuteScriptTxResult;
    }>;
    findBestRoute(token0: string, token1: string): Promise<bigint>;
    simulateSwap(p: SimulateSwap): Promise<LiquidityDistribution>;
    swap(p: ClmmSwapParams): Promise<SignExecuteScriptTxResult>;
    collectProtocolFees(p: CollectProtocolFees): Promise<SignExecuteScriptTxResult>;
    setRewardParams(p: SetRewardParams): Promise<SignExecuteScriptTxResult>;
    extendRewards(p: ExtendRewards): Promise<SignExecuteScriptTxResult>;
    private _getClmmConfig;
}

declare class TokenModule extends ModuleBase {
    private readonly cacheTimeDays;
    private cache?;
    private readonly cacheTimeMs;
    constructor(scope: Zeta, cacheTimeDays?: number);
    getTokens(): Promise<TokenInfo[]>;
    getTokenById(id: string): Promise<TokenInfo>;
    getTokenBySymbol(symbol: string): Promise<TokenInfo>;
    getTokenInfoBy(fn: (token: TokenInfo) => boolean): Promise<TokenInfo | undefined>;
    fetchTokens(): Promise<TokenInfo[]>;
    private isCacheValid;
    private extractTokens;
    private validateTokenListResponse;
    private validateTokenInfo;
}

declare namespace AlphUnstakeVaultTypes {
    type Fields = {
        xalphToken: HexString;
        unstakerAddress: Address;
        totalUnstakeAmount: bigint;
        unstakeStartTime: bigint;
        unstakeDuration: bigint;
        withdrawnAmount: bigint;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        mulDiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getTotalUnstakeAmount: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        getClaimableAmount: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        claim: {
            params: CallContractParams<{
                amount: bigint;
            }>;
            result: CallContractResult<boolean>;
        };
        destroy: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        mulDiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getTotalUnstakeAmount: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getClaimableAmount: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        claim: {
            params: SignExecuteContractMethodParams<{
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        destroy: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$i extends ContractFactory<AlphUnstakeVaultInstance, AlphUnstakeVaultTypes.Fields> {
    encodeFields(fields: AlphUnstakeVaultTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        FullMathError: {
            DivByZero: bigint;
            MulDivOverflow: bigint;
        };
        ErrorCodes: {
            InvalidCaller: bigint;
            InsufficientClaimableAmount: bigint;
            InvalidUnstakeDuration: bigint;
            InvalidTimestamp: bigint;
        };
    };
    at(address: string): AlphUnstakeVaultInstance;
    tests: {
        mulDiv: (params: TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        getTotalUnstakeAmount: (params: Omit<TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        getClaimableAmount: (params: Omit<TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        claim: (params: TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, {
            amount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<boolean>>;
        destroy: (params: Omit<TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<null>>;
    };
    stateForTest(initFields: AlphUnstakeVaultTypes.Fields, asset?: Asset, address?: string): ContractState<AlphUnstakeVaultTypes.Fields> | _alephium_web3.ContractStateWithMaps<AlphUnstakeVaultTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const AlphUnstakeVault: Factory$i;
declare class AlphUnstakeVaultInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<AlphUnstakeVaultTypes.State>;
    view: {
        mulDiv: (params: AlphUnstakeVaultTypes.CallMethodParams<"mulDiv">) => Promise<AlphUnstakeVaultTypes.CallMethodResult<"mulDiv">>;
        getTotalUnstakeAmount: (params?: AlphUnstakeVaultTypes.CallMethodParams<"getTotalUnstakeAmount">) => Promise<AlphUnstakeVaultTypes.CallMethodResult<"getTotalUnstakeAmount">>;
        getClaimableAmount: (params?: AlphUnstakeVaultTypes.CallMethodParams<"getClaimableAmount">) => Promise<AlphUnstakeVaultTypes.CallMethodResult<"getClaimableAmount">>;
        claim: (params: AlphUnstakeVaultTypes.CallMethodParams<"claim">) => Promise<AlphUnstakeVaultTypes.CallMethodResult<"claim">>;
        destroy: (params?: AlphUnstakeVaultTypes.CallMethodParams<"destroy">) => Promise<AlphUnstakeVaultTypes.CallMethodResult<"destroy">>;
    };
    transact: {
        mulDiv: (params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"mulDiv">) => Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"mulDiv">>;
        getTotalUnstakeAmount: (params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"getTotalUnstakeAmount">) => Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"getTotalUnstakeAmount">>;
        getClaimableAmount: (params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"getClaimableAmount">) => Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"getClaimableAmount">>;
        claim: (params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"claim">) => Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"claim">>;
        destroy: (params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"destroy">) => Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"destroy">>;
    };
    multicall<Calls extends AlphUnstakeVaultTypes.MultiCallParams>(calls: Calls): Promise<AlphUnstakeVaultTypes.MultiCallResults<Calls>>;
    multicall<Callss extends AlphUnstakeVaultTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<AlphUnstakeVaultTypes.MulticallReturnType<Callss>>;
}

declare namespace FullMathTestTypes$1 {
    type State = Omit<ContractState<any>, "fields">;
    interface CallMethodTable {
        mulDiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        mulDiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$h extends ContractFactory<FullMathTestInstance$1, {}> {
    encodeFields(): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        FullMathError: {
            DivByZero: bigint;
            MulDivOverflow: bigint;
        };
    };
    at(address: string): FullMathTestInstance$1;
    tests: {
        mulDiv: (params: Omit<TestContractParamsWithoutMaps<never, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
    };
    stateForTest(initFields: {}, asset?: Asset, address?: string): ContractState<{}> | _alephium_web3.ContractStateWithMaps<{}, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const FullMathTest$1: Factory$h;
declare class FullMathTestInstance$1 extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<FullMathTestTypes$1.State>;
    view: {
        mulDiv: (params: FullMathTestTypes$1.CallMethodParams<"mulDiv">) => Promise<FullMathTestTypes$1.CallMethodResult<"mulDiv">>;
    };
    transact: {
        mulDiv: (params: FullMathTestTypes$1.SignExecuteMethodParams<"mulDiv">) => Promise<FullMathTestTypes$1.SignExecuteMethodResult<"mulDiv">>;
    };
    multicall<Calls extends FullMathTestTypes$1.MultiCallParams>(calls: Calls): Promise<FullMathTestTypes$1.MultiCallResults<Calls>>;
    multicall<Callss extends FullMathTestTypes$1.MultiCallParams[]>(callss: Narrow<Callss>): Promise<FullMathTestTypes$1.MulticallReturnType<Callss>>;
}

interface UserRewardSharingInfo extends Record<string, Val> {
    amount: bigint;
    rewardPerToken: bigint;
}
interface UserStakingInfo extends Record<string, Val> {
    amount: bigint;
    connectedDapps: HexString;
}
interface VoteInfo extends Record<string, Val> {
    proposalVoted: bigint;
    amount: bigint;
}

declare namespace GovernanceDemoTypes {
    type Fields = {
        xalphStakeVault: HexString;
        proposalOptions: [bigint, bigint, bigint, bigint];
        owner: Address;
        totalVotedAmount: bigint;
        votingStartTime: bigint;
        votingEndTime: bigint;
    };
    type State = ContractState<Fields>;
    type VotingStartedEvent = ContractEvent<{
        votingStartTime: bigint;
    }>;
    type VoteCastEvent = ContractEvent<{
        voter: Address;
        proposalVoted: bigint;
        amount: bigint;
    }>;
    type VotingEndedEvent = ContractEvent<{
        votingEndTime: bigint;
    }>;
    interface CallMethodTable {
        onStake: {
            params: CallContractParams<{
                user: Address;
                addedAmount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        onUnstake: {
            params: CallContractParams<{
                user: Address;
                removedAmount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        startVoting: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<null>;
        };
        endVoting: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<null>;
        };
        getProposalOptions: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<[bigint, bigint, bigint, bigint]>;
        };
        getUserVote: {
            params: CallContractParams<{
                user: Address;
            }>;
            result: CallContractResult<VoteInfo>;
        };
        getProposalVotes: {
            params: CallContractParams<{
                proposal: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        getTotalVotedAmount: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        vote: {
            params: CallContractParams<{
                proposal: bigint;
            }>;
            result: CallContractResult<null>;
        };
        isVotingStarted: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<boolean>;
        };
        isVotingEnded: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<boolean>;
        };
        isVotingActive: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<boolean>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        onStake: {
            params: SignExecuteContractMethodParams<{
                user: Address;
                addedAmount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        onUnstake: {
            params: SignExecuteContractMethodParams<{
                user: Address;
                removedAmount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        startVoting: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        endVoting: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getProposalOptions: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getUserVote: {
            params: SignExecuteContractMethodParams<{
                user: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getProposalVotes: {
            params: SignExecuteContractMethodParams<{
                proposal: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getTotalVotedAmount: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        vote: {
            params: SignExecuteContractMethodParams<{
                proposal: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        isVotingStarted: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        isVotingEnded: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        isVotingActive: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
    type Maps = {
        userVotes?: Map<Address, VoteInfo>;
        proposalVotes?: Map<bigint, bigint>;
    };
}
declare class Factory$g extends ContractFactory<GovernanceDemoInstance, GovernanceDemoTypes.Fields> {
    encodeFields(fields: GovernanceDemoTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    eventIndex: {
        VotingStarted: number;
        VoteCast: number;
        VotingEnded: number;
    };
    consts: {
        ErrorCodes: {
            AssetAddressCallerOnly: bigint;
            UserNotStaked: bigint;
            InvalidVoteProposal: bigint;
            VotingNotStarted: bigint;
            VotingAlreadyStarted: bigint;
            VotingAlreadyEnded: bigint;
            AlreadyVoted: bigint;
            OwnerOnly: bigint;
            StakeVaultCallerOnly: bigint;
        };
    };
    at(address: string): GovernanceDemoInstance;
    tests: {
        onStake: (params: TestContractParams<GovernanceDemoTypes.Fields, {
            user: Address;
            addedAmount: bigint;
        }, GovernanceDemoTypes.Maps>) => Promise<TestContractResult<null, GovernanceDemoTypes.Maps>>;
        onUnstake: (params: TestContractParams<GovernanceDemoTypes.Fields, {
            user: Address;
            removedAmount: bigint;
        }, GovernanceDemoTypes.Maps>) => Promise<TestContractResult<null, GovernanceDemoTypes.Maps>>;
        startVoting: (params: Omit<TestContractParams<GovernanceDemoTypes.Fields, never, GovernanceDemoTypes.Maps>, "args">) => Promise<TestContractResult<null, GovernanceDemoTypes.Maps>>;
        endVoting: (params: Omit<TestContractParams<GovernanceDemoTypes.Fields, never, GovernanceDemoTypes.Maps>, "args">) => Promise<TestContractResult<null, GovernanceDemoTypes.Maps>>;
        getProposalOptions: (params: Omit<TestContractParams<GovernanceDemoTypes.Fields, never, GovernanceDemoTypes.Maps>, "args">) => Promise<TestContractResult<[bigint, bigint, bigint, bigint], GovernanceDemoTypes.Maps>>;
        getUserVote: (params: TestContractParams<GovernanceDemoTypes.Fields, {
            user: Address;
        }, GovernanceDemoTypes.Maps>) => Promise<TestContractResult<VoteInfo, GovernanceDemoTypes.Maps>>;
        getProposalVotes: (params: TestContractParams<GovernanceDemoTypes.Fields, {
            proposal: bigint;
        }, GovernanceDemoTypes.Maps>) => Promise<TestContractResult<bigint, GovernanceDemoTypes.Maps>>;
        getTotalVotedAmount: (params: Omit<TestContractParams<GovernanceDemoTypes.Fields, never, GovernanceDemoTypes.Maps>, "args">) => Promise<TestContractResult<bigint, GovernanceDemoTypes.Maps>>;
        vote: (params: TestContractParams<GovernanceDemoTypes.Fields, {
            proposal: bigint;
        }, GovernanceDemoTypes.Maps>) => Promise<TestContractResult<null, GovernanceDemoTypes.Maps>>;
        isVotingStarted: (params: Omit<TestContractParams<GovernanceDemoTypes.Fields, never, GovernanceDemoTypes.Maps>, "args">) => Promise<TestContractResult<boolean, GovernanceDemoTypes.Maps>>;
        isVotingEnded: (params: Omit<TestContractParams<GovernanceDemoTypes.Fields, never, GovernanceDemoTypes.Maps>, "args">) => Promise<TestContractResult<boolean, GovernanceDemoTypes.Maps>>;
        isVotingActive: (params: Omit<TestContractParams<GovernanceDemoTypes.Fields, never, GovernanceDemoTypes.Maps>, "args">) => Promise<TestContractResult<boolean, GovernanceDemoTypes.Maps>>;
    };
    stateForTest(initFields: GovernanceDemoTypes.Fields, asset?: Asset, address?: string, maps?: GovernanceDemoTypes.Maps): ContractState<GovernanceDemoTypes.Fields> | _alephium_web3.ContractStateWithMaps<GovernanceDemoTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const GovernanceDemo: Factory$g;
declare class GovernanceDemoInstance extends ContractInstance {
    constructor(address: Address);
    maps: {
        userVotes: RalphMap<string, VoteInfo>;
        proposalVotes: RalphMap<bigint, bigint>;
    };
    fetchState(): Promise<GovernanceDemoTypes.State>;
    getContractEventsCurrentCount(): Promise<number>;
    subscribeVotingStartedEvent(options: EventSubscribeOptions<GovernanceDemoTypes.VotingStartedEvent>, fromCount?: number): EventSubscription;
    subscribeVoteCastEvent(options: EventSubscribeOptions<GovernanceDemoTypes.VoteCastEvent>, fromCount?: number): EventSubscription;
    subscribeVotingEndedEvent(options: EventSubscribeOptions<GovernanceDemoTypes.VotingEndedEvent>, fromCount?: number): EventSubscription;
    subscribeAllEvents(options: EventSubscribeOptions<GovernanceDemoTypes.VotingStartedEvent | GovernanceDemoTypes.VoteCastEvent | GovernanceDemoTypes.VotingEndedEvent>, fromCount?: number): EventSubscription;
    view: {
        onStake: (params: GovernanceDemoTypes.CallMethodParams<"onStake">) => Promise<GovernanceDemoTypes.CallMethodResult<"onStake">>;
        onUnstake: (params: GovernanceDemoTypes.CallMethodParams<"onUnstake">) => Promise<GovernanceDemoTypes.CallMethodResult<"onUnstake">>;
        startVoting: (params?: GovernanceDemoTypes.CallMethodParams<"startVoting">) => Promise<GovernanceDemoTypes.CallMethodResult<"startVoting">>;
        endVoting: (params?: GovernanceDemoTypes.CallMethodParams<"endVoting">) => Promise<GovernanceDemoTypes.CallMethodResult<"endVoting">>;
        getProposalOptions: (params?: GovernanceDemoTypes.CallMethodParams<"getProposalOptions">) => Promise<GovernanceDemoTypes.CallMethodResult<"getProposalOptions">>;
        getUserVote: (params: GovernanceDemoTypes.CallMethodParams<"getUserVote">) => Promise<GovernanceDemoTypes.CallMethodResult<"getUserVote">>;
        getProposalVotes: (params: GovernanceDemoTypes.CallMethodParams<"getProposalVotes">) => Promise<GovernanceDemoTypes.CallMethodResult<"getProposalVotes">>;
        getTotalVotedAmount: (params?: GovernanceDemoTypes.CallMethodParams<"getTotalVotedAmount">) => Promise<GovernanceDemoTypes.CallMethodResult<"getTotalVotedAmount">>;
        vote: (params: GovernanceDemoTypes.CallMethodParams<"vote">) => Promise<GovernanceDemoTypes.CallMethodResult<"vote">>;
        isVotingStarted: (params?: GovernanceDemoTypes.CallMethodParams<"isVotingStarted">) => Promise<GovernanceDemoTypes.CallMethodResult<"isVotingStarted">>;
        isVotingEnded: (params?: GovernanceDemoTypes.CallMethodParams<"isVotingEnded">) => Promise<GovernanceDemoTypes.CallMethodResult<"isVotingEnded">>;
        isVotingActive: (params?: GovernanceDemoTypes.CallMethodParams<"isVotingActive">) => Promise<GovernanceDemoTypes.CallMethodResult<"isVotingActive">>;
    };
    transact: {
        onStake: (params: GovernanceDemoTypes.SignExecuteMethodParams<"onStake">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"onStake">>;
        onUnstake: (params: GovernanceDemoTypes.SignExecuteMethodParams<"onUnstake">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"onUnstake">>;
        startVoting: (params: GovernanceDemoTypes.SignExecuteMethodParams<"startVoting">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"startVoting">>;
        endVoting: (params: GovernanceDemoTypes.SignExecuteMethodParams<"endVoting">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"endVoting">>;
        getProposalOptions: (params: GovernanceDemoTypes.SignExecuteMethodParams<"getProposalOptions">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"getProposalOptions">>;
        getUserVote: (params: GovernanceDemoTypes.SignExecuteMethodParams<"getUserVote">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"getUserVote">>;
        getProposalVotes: (params: GovernanceDemoTypes.SignExecuteMethodParams<"getProposalVotes">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"getProposalVotes">>;
        getTotalVotedAmount: (params: GovernanceDemoTypes.SignExecuteMethodParams<"getTotalVotedAmount">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"getTotalVotedAmount">>;
        vote: (params: GovernanceDemoTypes.SignExecuteMethodParams<"vote">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"vote">>;
        isVotingStarted: (params: GovernanceDemoTypes.SignExecuteMethodParams<"isVotingStarted">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"isVotingStarted">>;
        isVotingEnded: (params: GovernanceDemoTypes.SignExecuteMethodParams<"isVotingEnded">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"isVotingEnded">>;
        isVotingActive: (params: GovernanceDemoTypes.SignExecuteMethodParams<"isVotingActive">) => Promise<GovernanceDemoTypes.SignExecuteMethodResult<"isVotingActive">>;
    };
    multicall<Calls extends GovernanceDemoTypes.MultiCallParams>(calls: Calls): Promise<GovernanceDemoTypes.MultiCallResults<Calls>>;
    multicall<Callss extends GovernanceDemoTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<GovernanceDemoTypes.MulticallReturnType<Callss>>;
}

declare namespace RewardSharingVaultTypes {
    type Fields = {
        stakeVault: HexString;
        rewardTokenId: HexString;
        totalAmountStaked: bigint;
        rewardPerTokenCumulative: bigint;
    };
    type State = ContractState<Fields>;
    type StakedEvent = ContractEvent<{
        staker: Address;
        amount: bigint;
    }>;
    type UnstakedEvent = ContractEvent<{
        staker: Address;
        amount: bigint;
    }>;
    type RewardDepositedEvent = ContractEvent<{
        depositor: Address;
        amount: bigint;
    }>;
    type RewardClaimedEvent = ContractEvent<{
        staker: Address;
        amount: bigint;
    }>;
    interface CallMethodTable {
        onStake: {
            params: CallContractParams<{
                user: Address;
                newStakedAmount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        onUnstake: {
            params: CallContractParams<{
                user: Address;
                unstakedAmount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        mulDiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        depositReward: {
            params: CallContractParams<{
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        claimPendingRewards: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<null>;
        };
        claimUserPendingRewards: {
            params: CallContractParams<{
                user: Address;
            }>;
            result: CallContractResult<null>;
        };
        getUserPendingRewards: {
            params: CallContractParams<{
                user: Address;
            }>;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        onStake: {
            params: SignExecuteContractMethodParams<{
                user: Address;
                newStakedAmount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        onUnstake: {
            params: SignExecuteContractMethodParams<{
                user: Address;
                unstakedAmount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        depositReward: {
            params: SignExecuteContractMethodParams<{
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        claimPendingRewards: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        claimUserPendingRewards: {
            params: SignExecuteContractMethodParams<{
                user: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getUserPendingRewards: {
            params: SignExecuteContractMethodParams<{
                user: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
    type Maps = {
        userRewardSharingInfo?: Map<Address, UserRewardSharingInfo>;
    };
}
declare class Factory$f extends ContractFactory<RewardSharingVaultInstance, RewardSharingVaultTypes.Fields> {
    encodeFields(fields: RewardSharingVaultTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    eventIndex: {
        Staked: number;
        Unstaked: number;
        RewardDeposited: number;
        RewardClaimed: number;
    };
    consts: {
        SCALING_FACTOR: bigint;
        FullMathError: {
            DivByZero: bigint;
            MulDivOverflow: bigint;
        };
        ErrorCodes: {
            StakeVaultCallerOnly: bigint;
            NoUserRewardSharingInfo: bigint;
            TotalStakedAmountIsZero: bigint;
            InvalidStakedAmount: bigint;
            InvalidUnstakedAmount: bigint;
        };
    };
    at(address: string): RewardSharingVaultInstance;
    tests: {
        onStake: (params: TestContractParams<RewardSharingVaultTypes.Fields, {
            user: Address;
            newStakedAmount: bigint;
        }, RewardSharingVaultTypes.Maps>) => Promise<TestContractResult<null, RewardSharingVaultTypes.Maps>>;
        onUnstake: (params: TestContractParams<RewardSharingVaultTypes.Fields, {
            user: Address;
            unstakedAmount: bigint;
        }, RewardSharingVaultTypes.Maps>) => Promise<TestContractResult<null, RewardSharingVaultTypes.Maps>>;
        mulDiv: (params: TestContractParams<RewardSharingVaultTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }, RewardSharingVaultTypes.Maps>) => Promise<TestContractResult<bigint, RewardSharingVaultTypes.Maps>>;
        depositReward: (params: TestContractParams<RewardSharingVaultTypes.Fields, {
            amount: bigint;
        }, RewardSharingVaultTypes.Maps>) => Promise<TestContractResult<null, RewardSharingVaultTypes.Maps>>;
        claimPendingRewards: (params: Omit<TestContractParams<RewardSharingVaultTypes.Fields, never, RewardSharingVaultTypes.Maps>, "args">) => Promise<TestContractResult<null, RewardSharingVaultTypes.Maps>>;
        claimUserPendingRewards: (params: TestContractParams<RewardSharingVaultTypes.Fields, {
            user: Address;
        }, RewardSharingVaultTypes.Maps>) => Promise<TestContractResult<null, RewardSharingVaultTypes.Maps>>;
        getUserPendingRewards: (params: TestContractParams<RewardSharingVaultTypes.Fields, {
            user: Address;
        }, RewardSharingVaultTypes.Maps>) => Promise<TestContractResult<bigint, RewardSharingVaultTypes.Maps>>;
    };
    stateForTest(initFields: RewardSharingVaultTypes.Fields, asset?: Asset, address?: string, maps?: RewardSharingVaultTypes.Maps): ContractState<RewardSharingVaultTypes.Fields> | _alephium_web3.ContractStateWithMaps<RewardSharingVaultTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const RewardSharingVault: Factory$f;
declare class RewardSharingVaultInstance extends ContractInstance {
    constructor(address: Address);
    maps: {
        userRewardSharingInfo: RalphMap<string, UserRewardSharingInfo>;
    };
    fetchState(): Promise<RewardSharingVaultTypes.State>;
    getContractEventsCurrentCount(): Promise<number>;
    subscribeStakedEvent(options: EventSubscribeOptions<RewardSharingVaultTypes.StakedEvent>, fromCount?: number): EventSubscription;
    subscribeUnstakedEvent(options: EventSubscribeOptions<RewardSharingVaultTypes.UnstakedEvent>, fromCount?: number): EventSubscription;
    subscribeRewardDepositedEvent(options: EventSubscribeOptions<RewardSharingVaultTypes.RewardDepositedEvent>, fromCount?: number): EventSubscription;
    subscribeRewardClaimedEvent(options: EventSubscribeOptions<RewardSharingVaultTypes.RewardClaimedEvent>, fromCount?: number): EventSubscription;
    subscribeAllEvents(options: EventSubscribeOptions<RewardSharingVaultTypes.StakedEvent | RewardSharingVaultTypes.UnstakedEvent | RewardSharingVaultTypes.RewardDepositedEvent | RewardSharingVaultTypes.RewardClaimedEvent>, fromCount?: number): EventSubscription;
    view: {
        onStake: (params: RewardSharingVaultTypes.CallMethodParams<"onStake">) => Promise<RewardSharingVaultTypes.CallMethodResult<"onStake">>;
        onUnstake: (params: RewardSharingVaultTypes.CallMethodParams<"onUnstake">) => Promise<RewardSharingVaultTypes.CallMethodResult<"onUnstake">>;
        mulDiv: (params: RewardSharingVaultTypes.CallMethodParams<"mulDiv">) => Promise<RewardSharingVaultTypes.CallMethodResult<"mulDiv">>;
        depositReward: (params: RewardSharingVaultTypes.CallMethodParams<"depositReward">) => Promise<RewardSharingVaultTypes.CallMethodResult<"depositReward">>;
        claimPendingRewards: (params?: RewardSharingVaultTypes.CallMethodParams<"claimPendingRewards">) => Promise<RewardSharingVaultTypes.CallMethodResult<"claimPendingRewards">>;
        claimUserPendingRewards: (params: RewardSharingVaultTypes.CallMethodParams<"claimUserPendingRewards">) => Promise<RewardSharingVaultTypes.CallMethodResult<"claimUserPendingRewards">>;
        getUserPendingRewards: (params: RewardSharingVaultTypes.CallMethodParams<"getUserPendingRewards">) => Promise<RewardSharingVaultTypes.CallMethodResult<"getUserPendingRewards">>;
    };
    transact: {
        onStake: (params: RewardSharingVaultTypes.SignExecuteMethodParams<"onStake">) => Promise<RewardSharingVaultTypes.SignExecuteMethodResult<"onStake">>;
        onUnstake: (params: RewardSharingVaultTypes.SignExecuteMethodParams<"onUnstake">) => Promise<RewardSharingVaultTypes.SignExecuteMethodResult<"onUnstake">>;
        mulDiv: (params: RewardSharingVaultTypes.SignExecuteMethodParams<"mulDiv">) => Promise<RewardSharingVaultTypes.SignExecuteMethodResult<"mulDiv">>;
        depositReward: (params: RewardSharingVaultTypes.SignExecuteMethodParams<"depositReward">) => Promise<RewardSharingVaultTypes.SignExecuteMethodResult<"depositReward">>;
        claimPendingRewards: (params: RewardSharingVaultTypes.SignExecuteMethodParams<"claimPendingRewards">) => Promise<RewardSharingVaultTypes.SignExecuteMethodResult<"claimPendingRewards">>;
        claimUserPendingRewards: (params: RewardSharingVaultTypes.SignExecuteMethodParams<"claimUserPendingRewards">) => Promise<RewardSharingVaultTypes.SignExecuteMethodResult<"claimUserPendingRewards">>;
        getUserPendingRewards: (params: RewardSharingVaultTypes.SignExecuteMethodParams<"getUserPendingRewards">) => Promise<RewardSharingVaultTypes.SignExecuteMethodResult<"getUserPendingRewards">>;
    };
    multicall<Calls extends RewardSharingVaultTypes.MultiCallParams>(calls: Calls): Promise<RewardSharingVaultTypes.MultiCallResults<Calls>>;
    multicall<Callss extends RewardSharingVaultTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<RewardSharingVaultTypes.MulticallReturnType<Callss>>;
}

declare namespace TestDynamicArrayByteVec32Types {
    type State = Omit<ContractState<any>, "fields">;
    interface CallMethodTable {
        get: {
            params: CallContractParams<{
                array: HexString;
                index: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        find: {
            params: CallContractParams<{
                array: HexString;
                value: HexString;
            }>;
            result: CallContractResult<bigint>;
        };
        remove: {
            params: CallContractParams<{
                array: HexString;
                value: HexString;
            }>;
            result: CallContractResult<HexString>;
        };
        push: {
            params: CallContractParams<{
                array: HexString;
                value: HexString;
            }>;
            result: CallContractResult<HexString>;
        };
        removeAt: {
            params: CallContractParams<{
                array: HexString;
                index: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        size: {
            params: CallContractParams<{
                array: HexString;
            }>;
            result: CallContractResult<bigint>;
        };
        empty: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        get: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                index: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        find: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        remove: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        push: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        removeAt: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                index: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        size: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        empty: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$e extends ContractFactory<TestDynamicArrayByteVec32Instance, {}> {
    encodeFields(): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        IntByteLength: bigint;
        ErrorCode: {
            InvalidArrayLength: bigint;
            IndexOutOfBound: bigint;
            InvalidByteVecLength: bigint;
        };
    };
    at(address: string): TestDynamicArrayByteVec32Instance;
    tests: {
        get: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            index: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<HexString>>;
        find: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            value: HexString;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        remove: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            value: HexString;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<HexString>>;
        push: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            value: HexString;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<HexString>>;
        removeAt: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            index: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<HexString>>;
        size: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        empty: (params?: Omit<TestContractParamsWithoutMaps<never, never>, "args" | "initialFields">) => Promise<TestContractResultWithoutMaps<HexString>>;
    };
    stateForTest(initFields: {}, asset?: Asset, address?: string): ContractState<{}> | _alephium_web3.ContractStateWithMaps<{}, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const TestDynamicArrayByteVec32: Factory$e;
declare class TestDynamicArrayByteVec32Instance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<TestDynamicArrayByteVec32Types.State>;
    view: {
        get: (params: TestDynamicArrayByteVec32Types.CallMethodParams<"get">) => Promise<TestDynamicArrayByteVec32Types.CallMethodResult<"get">>;
        find: (params: TestDynamicArrayByteVec32Types.CallMethodParams<"find">) => Promise<TestDynamicArrayByteVec32Types.CallMethodResult<"find">>;
        remove: (params: TestDynamicArrayByteVec32Types.CallMethodParams<"remove">) => Promise<TestDynamicArrayByteVec32Types.CallMethodResult<"remove">>;
        push: (params: TestDynamicArrayByteVec32Types.CallMethodParams<"push">) => Promise<TestDynamicArrayByteVec32Types.CallMethodResult<"push">>;
        removeAt: (params: TestDynamicArrayByteVec32Types.CallMethodParams<"removeAt">) => Promise<TestDynamicArrayByteVec32Types.CallMethodResult<"removeAt">>;
        size: (params: TestDynamicArrayByteVec32Types.CallMethodParams<"size">) => Promise<TestDynamicArrayByteVec32Types.CallMethodResult<"size">>;
        empty: (params?: TestDynamicArrayByteVec32Types.CallMethodParams<"empty">) => Promise<TestDynamicArrayByteVec32Types.CallMethodResult<"empty">>;
    };
    transact: {
        get: (params: TestDynamicArrayByteVec32Types.SignExecuteMethodParams<"get">) => Promise<TestDynamicArrayByteVec32Types.SignExecuteMethodResult<"get">>;
        find: (params: TestDynamicArrayByteVec32Types.SignExecuteMethodParams<"find">) => Promise<TestDynamicArrayByteVec32Types.SignExecuteMethodResult<"find">>;
        remove: (params: TestDynamicArrayByteVec32Types.SignExecuteMethodParams<"remove">) => Promise<TestDynamicArrayByteVec32Types.SignExecuteMethodResult<"remove">>;
        push: (params: TestDynamicArrayByteVec32Types.SignExecuteMethodParams<"push">) => Promise<TestDynamicArrayByteVec32Types.SignExecuteMethodResult<"push">>;
        removeAt: (params: TestDynamicArrayByteVec32Types.SignExecuteMethodParams<"removeAt">) => Promise<TestDynamicArrayByteVec32Types.SignExecuteMethodResult<"removeAt">>;
        size: (params: TestDynamicArrayByteVec32Types.SignExecuteMethodParams<"size">) => Promise<TestDynamicArrayByteVec32Types.SignExecuteMethodResult<"size">>;
        empty: (params: TestDynamicArrayByteVec32Types.SignExecuteMethodParams<"empty">) => Promise<TestDynamicArrayByteVec32Types.SignExecuteMethodResult<"empty">>;
    };
    multicall<Calls extends TestDynamicArrayByteVec32Types.MultiCallParams>(calls: Calls): Promise<TestDynamicArrayByteVec32Types.MultiCallResults<Calls>>;
    multicall<Callss extends TestDynamicArrayByteVec32Types.MultiCallParams[]>(callss: Narrow<Callss>): Promise<TestDynamicArrayByteVec32Types.MulticallReturnType<Callss>>;
}

declare namespace TestDynamicSortedArrayForU256Types {
    type State = Omit<ContractState<any>, "fields">;
    interface CallMethodTable {
        get: {
            params: CallContractParams<{
                array: HexString;
                index: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        find: {
            params: CallContractParams<{
                array: HexString;
                value: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        remove: {
            params: CallContractParams<{
                array: HexString;
                value: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        push: {
            params: CallContractParams<{
                array: HexString;
                value: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        binarySearch: {
            params: CallContractParams<{
                array: HexString;
                value: bigint;
                left: bigint;
                right: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        removeAt: {
            params: CallContractParams<{
                array: HexString;
                index: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        size: {
            params: CallContractParams<{
                array: HexString;
            }>;
            result: CallContractResult<bigint>;
        };
        empty: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        get: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                index: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        find: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        remove: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        push: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        binarySearch: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: bigint;
                left: bigint;
                right: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        removeAt: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                index: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        size: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        empty: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$d extends ContractFactory<TestDynamicSortedArrayForU256Instance, {}> {
    encodeFields(): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        IntByteLength: bigint;
        ErrorCode: {
            InvalidArrayLength: bigint;
            IndexOutOfBound: bigint;
            InvalidByteVecLength: bigint;
        };
    };
    at(address: string): TestDynamicSortedArrayForU256Instance;
    tests: {
        get: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            index: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        find: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            value: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        remove: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            value: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<HexString>>;
        push: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            value: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<HexString>>;
        binarySearch: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            value: bigint;
            left: bigint;
            right: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        removeAt: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
            index: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<HexString>>;
        size: (params: Omit<TestContractParamsWithoutMaps<never, {
            array: HexString;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        empty: (params?: Omit<TestContractParamsWithoutMaps<never, never>, "args" | "initialFields">) => Promise<TestContractResultWithoutMaps<HexString>>;
    };
    stateForTest(initFields: {}, asset?: Asset, address?: string): ContractState<{}> | _alephium_web3.ContractStateWithMaps<{}, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const TestDynamicSortedArrayForU256: Factory$d;
declare class TestDynamicSortedArrayForU256Instance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<TestDynamicSortedArrayForU256Types.State>;
    view: {
        get: (params: TestDynamicSortedArrayForU256Types.CallMethodParams<"get">) => Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"get">>;
        find: (params: TestDynamicSortedArrayForU256Types.CallMethodParams<"find">) => Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"find">>;
        remove: (params: TestDynamicSortedArrayForU256Types.CallMethodParams<"remove">) => Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"remove">>;
        push: (params: TestDynamicSortedArrayForU256Types.CallMethodParams<"push">) => Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"push">>;
        binarySearch: (params: TestDynamicSortedArrayForU256Types.CallMethodParams<"binarySearch">) => Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"binarySearch">>;
        removeAt: (params: TestDynamicSortedArrayForU256Types.CallMethodParams<"removeAt">) => Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"removeAt">>;
        size: (params: TestDynamicSortedArrayForU256Types.CallMethodParams<"size">) => Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"size">>;
        empty: (params?: TestDynamicSortedArrayForU256Types.CallMethodParams<"empty">) => Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"empty">>;
    };
    transact: {
        get: (params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"get">) => Promise<TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"get">>;
        find: (params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"find">) => Promise<TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"find">>;
        remove: (params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"remove">) => Promise<TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"remove">>;
        push: (params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"push">) => Promise<TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"push">>;
        binarySearch: (params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"binarySearch">) => Promise<TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"binarySearch">>;
        removeAt: (params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"removeAt">) => Promise<TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"removeAt">>;
        size: (params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"size">) => Promise<TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"size">>;
        empty: (params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"empty">) => Promise<TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"empty">>;
    };
    multicall<Calls extends TestDynamicSortedArrayForU256Types.MultiCallParams>(calls: Calls): Promise<TestDynamicSortedArrayForU256Types.MultiCallResults<Calls>>;
    multicall<Callss extends TestDynamicSortedArrayForU256Types.MultiCallParams[]>(callss: Narrow<Callss>): Promise<TestDynamicSortedArrayForU256Types.MulticallReturnType<Callss>>;
}

declare namespace TestMerkleProofTypes {
    type Fields = {
        merkleRoot: HexString;
    };
    type State = ContractState<Fields>;
    type UpdateRootEvent = ContractEvent<{
        newMerkleRoot: HexString;
        updatedBy: Address;
    }>;
    interface CallMethodTable {
        getMerkleRoot: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        updateRoot: {
            params: CallContractParams<{
                newMerkleRoot: HexString;
            }>;
            result: CallContractResult<null>;
        };
        verify: {
            params: CallContractParams<{
                proof: HexString;
                dataHash: HexString;
            }>;
            result: CallContractResult<boolean>;
        };
        hashPair: {
            params: CallContractParams<{
                a: HexString;
                b: HexString;
            }>;
            result: CallContractResult<HexString>;
        };
        hash: {
            params: CallContractParams<{
                dataToHash: HexString;
            }>;
            result: CallContractResult<HexString>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        getMerkleRoot: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        updateRoot: {
            params: SignExecuteContractMethodParams<{
                newMerkleRoot: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        verify: {
            params: SignExecuteContractMethodParams<{
                proof: HexString;
                dataHash: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        hashPair: {
            params: SignExecuteContractMethodParams<{
                a: HexString;
                b: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        hash: {
            params: SignExecuteContractMethodParams<{
                dataToHash: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$c extends ContractFactory<TestMerkleProofInstance, TestMerkleProofTypes.Fields> {
    encodeFields(fields: TestMerkleProofTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    eventIndex: {
        UpdateRoot: number;
    };
    consts: {
        MerkleProofErrorCodes: {
            InvalidProofSize: bigint;
            InvalidDataHash: bigint;
            InvalidMerkleRoot: bigint;
        };
    };
    at(address: string): TestMerkleProofInstance;
    tests: {
        getMerkleRoot: (params: Omit<TestContractParamsWithoutMaps<TestMerkleProofTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<HexString>>;
        updateRoot: (params: TestContractParamsWithoutMaps<TestMerkleProofTypes.Fields, {
            newMerkleRoot: HexString;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        verify: (params: TestContractParamsWithoutMaps<TestMerkleProofTypes.Fields, {
            proof: HexString;
            dataHash: HexString;
        }>) => Promise<TestContractResultWithoutMaps<boolean>>;
        hashPair: (params: TestContractParamsWithoutMaps<TestMerkleProofTypes.Fields, {
            a: HexString;
            b: HexString;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
        hash: (params: TestContractParamsWithoutMaps<TestMerkleProofTypes.Fields, {
            dataToHash: HexString;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
    };
    stateForTest(initFields: TestMerkleProofTypes.Fields, asset?: Asset, address?: string): ContractState<TestMerkleProofTypes.Fields> | _alephium_web3.ContractStateWithMaps<TestMerkleProofTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const TestMerkleProof: Factory$c;
declare class TestMerkleProofInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<TestMerkleProofTypes.State>;
    getContractEventsCurrentCount(): Promise<number>;
    subscribeUpdateRootEvent(options: EventSubscribeOptions<TestMerkleProofTypes.UpdateRootEvent>, fromCount?: number): EventSubscription;
    view: {
        getMerkleRoot: (params?: TestMerkleProofTypes.CallMethodParams<"getMerkleRoot">) => Promise<TestMerkleProofTypes.CallMethodResult<"getMerkleRoot">>;
        updateRoot: (params: TestMerkleProofTypes.CallMethodParams<"updateRoot">) => Promise<TestMerkleProofTypes.CallMethodResult<"updateRoot">>;
        verify: (params: TestMerkleProofTypes.CallMethodParams<"verify">) => Promise<TestMerkleProofTypes.CallMethodResult<"verify">>;
        hashPair: (params: TestMerkleProofTypes.CallMethodParams<"hashPair">) => Promise<TestMerkleProofTypes.CallMethodResult<"hashPair">>;
        hash: (params: TestMerkleProofTypes.CallMethodParams<"hash">) => Promise<TestMerkleProofTypes.CallMethodResult<"hash">>;
    };
    transact: {
        getMerkleRoot: (params: TestMerkleProofTypes.SignExecuteMethodParams<"getMerkleRoot">) => Promise<TestMerkleProofTypes.SignExecuteMethodResult<"getMerkleRoot">>;
        updateRoot: (params: TestMerkleProofTypes.SignExecuteMethodParams<"updateRoot">) => Promise<TestMerkleProofTypes.SignExecuteMethodResult<"updateRoot">>;
        verify: (params: TestMerkleProofTypes.SignExecuteMethodParams<"verify">) => Promise<TestMerkleProofTypes.SignExecuteMethodResult<"verify">>;
        hashPair: (params: TestMerkleProofTypes.SignExecuteMethodParams<"hashPair">) => Promise<TestMerkleProofTypes.SignExecuteMethodResult<"hashPair">>;
        hash: (params: TestMerkleProofTypes.SignExecuteMethodParams<"hash">) => Promise<TestMerkleProofTypes.SignExecuteMethodResult<"hash">>;
    };
    multicall<Calls extends TestMerkleProofTypes.MultiCallParams>(calls: Calls): Promise<TestMerkleProofTypes.MultiCallResults<Calls>>;
    multicall<Callss extends TestMerkleProofTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<TestMerkleProofTypes.MulticallReturnType<Callss>>;
}

declare namespace XAlphStakeVaultTypes {
    type Fields = {
        stakeTokenId: HexString;
        maxConnectedDapps: bigint;
        merkleRoot: HexString;
        totalStakedAmount: bigint;
        owner: Address;
    };
    type State = ContractState<Fields>;
    type UpdateRootEvent = ContractEvent<{
        newMerkleRoot: HexString;
        updatedBy: Address;
    }>;
    type StakedEvent = ContractEvent<{
        staker: Address;
        amount: bigint;
    }>;
    type UnstakedEvent = ContractEvent<{
        staker: Address;
        amount: bigint;
    }>;
    interface CallMethodTable {
        get: {
            params: CallContractParams<{
                array: HexString;
                index: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        find: {
            params: CallContractParams<{
                array: HexString;
                value: HexString;
            }>;
            result: CallContractResult<bigint>;
        };
        remove: {
            params: CallContractParams<{
                array: HexString;
                value: HexString;
            }>;
            result: CallContractResult<HexString>;
        };
        push: {
            params: CallContractParams<{
                array: HexString;
                value: HexString;
            }>;
            result: CallContractResult<HexString>;
        };
        removeAt: {
            params: CallContractParams<{
                array: HexString;
                index: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        size: {
            params: CallContractParams<{
                array: HexString;
            }>;
            result: CallContractResult<bigint>;
        };
        empty: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getMerkleRoot: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        updateRoot: {
            params: CallContractParams<{
                newMerkleRoot: HexString;
            }>;
            result: CallContractResult<null>;
        };
        verify: {
            params: CallContractParams<{
                proof: HexString;
                dataHash: HexString;
            }>;
            result: CallContractResult<boolean>;
        };
        hashPair: {
            params: CallContractParams<{
                a: HexString;
                b: HexString;
            }>;
            result: CallContractResult<HexString>;
        };
        hash: {
            params: CallContractParams<{
                dataToHash: HexString;
            }>;
            result: CallContractResult<HexString>;
        };
        getStakeTokenId: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getUserStakingInfo: {
            params: CallContractParams<{
                user: Address;
            }>;
            result: CallContractResult<UserStakingInfo>;
        };
        isStaking: {
            params: CallContractParams<{
                user: Address;
            }>;
            result: CallContractResult<boolean>;
        };
        stake: {
            params: CallContractParams<{
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        unstake: {
            params: CallContractParams<{
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        connectToDapp: {
            params: CallContractParams<{
                contractId: HexString;
                merkleProof: HexString;
            }>;
            result: CallContractResult<null>;
        };
        disconnectFromDapp: {
            params: CallContractParams<{
                contractId: HexString;
            }>;
            result: CallContractResult<null>;
        };
        getWeight: {
            params: CallContractParams<{
                user: Address;
            }>;
            result: CallContractResult<bigint>;
        };
        updateDappTemplatesWhitelistMerkleRoot: {
            params: CallContractParams<{
                newMerkleRoot: HexString;
            }>;
            result: CallContractResult<null>;
        };
        updateOwner: {
            params: CallContractParams<{
                newOwner: Address;
            }>;
            result: CallContractResult<null>;
        };
        verifyDappTemplatesWhiteListed: {
            params: CallContractParams<{
                proof: HexString;
                contractId: HexString;
            }>;
            result: CallContractResult<boolean>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        get: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                index: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        find: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        remove: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        push: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        removeAt: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                index: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        size: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        empty: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getMerkleRoot: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        updateRoot: {
            params: SignExecuteContractMethodParams<{
                newMerkleRoot: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        verify: {
            params: SignExecuteContractMethodParams<{
                proof: HexString;
                dataHash: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        hashPair: {
            params: SignExecuteContractMethodParams<{
                a: HexString;
                b: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        hash: {
            params: SignExecuteContractMethodParams<{
                dataToHash: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getStakeTokenId: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getUserStakingInfo: {
            params: SignExecuteContractMethodParams<{
                user: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        isStaking: {
            params: SignExecuteContractMethodParams<{
                user: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        stake: {
            params: SignExecuteContractMethodParams<{
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        unstake: {
            params: SignExecuteContractMethodParams<{
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        connectToDapp: {
            params: SignExecuteContractMethodParams<{
                contractId: HexString;
                merkleProof: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        disconnectFromDapp: {
            params: SignExecuteContractMethodParams<{
                contractId: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getWeight: {
            params: SignExecuteContractMethodParams<{
                user: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        updateDappTemplatesWhitelistMerkleRoot: {
            params: SignExecuteContractMethodParams<{
                newMerkleRoot: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        updateOwner: {
            params: SignExecuteContractMethodParams<{
                newOwner: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        verifyDappTemplatesWhiteListed: {
            params: SignExecuteContractMethodParams<{
                proof: HexString;
                contractId: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
    type Maps = {
        userStakingInfo?: Map<Address, UserStakingInfo>;
    };
}
declare class Factory$b extends ContractFactory<XAlphStakeVaultInstance, XAlphStakeVaultTypes.Fields> {
    encodeFields(fields: XAlphStakeVaultTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    eventIndex: {
        UpdateRoot: number;
        Staked: number;
        Unstaked: number;
    };
    consts: {
        IntByteLength: bigint;
        WEIGHT_SCALING_FACTOR: bigint;
        ErrorCode: {
            InvalidArrayLength: bigint;
            IndexOutOfBound: bigint;
            InvalidByteVecLength: bigint;
        };
        MerkleProofErrorCodes: {
            InvalidProofSize: bigint;
            InvalidDataHash: bigint;
            InvalidMerkleRoot: bigint;
        };
        ErrorCodes: {
            NotOwner: bigint;
            AssetAddressCallerOnly: bigint;
            NoStakingInfo: bigint;
            InsufficientStakedAmount: bigint;
            InvalidStakedAmount: bigint;
            InvalidUnstakedAmount: bigint;
            MaxConnectedDappsReached: bigint;
            DappAlreadyConnected: bigint;
            DappNotConnected: bigint;
            DappNotAllowed: bigint;
        };
    };
    at(address: string): XAlphStakeVaultInstance;
    tests: {
        get: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            array: HexString;
            index: bigint;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>>;
        find: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            array: HexString;
            value: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<bigint, XAlphStakeVaultTypes.Maps>>;
        remove: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            array: HexString;
            value: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>>;
        push: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            array: HexString;
            value: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>>;
        removeAt: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            array: HexString;
            index: bigint;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>>;
        size: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            array: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<bigint, XAlphStakeVaultTypes.Maps>>;
        empty: (params: Omit<TestContractParams<XAlphStakeVaultTypes.Fields, never, XAlphStakeVaultTypes.Maps>, "args">) => Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>>;
        getMerkleRoot: (params: Omit<TestContractParams<XAlphStakeVaultTypes.Fields, never, XAlphStakeVaultTypes.Maps>, "args">) => Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>>;
        updateRoot: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            newMerkleRoot: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>>;
        verify: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            proof: HexString;
            dataHash: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<boolean, XAlphStakeVaultTypes.Maps>>;
        hashPair: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            a: HexString;
            b: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>>;
        hash: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            dataToHash: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>>;
        getStakeTokenId: (params: Omit<TestContractParams<XAlphStakeVaultTypes.Fields, never, XAlphStakeVaultTypes.Maps>, "args">) => Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>>;
        getUserStakingInfo: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            user: Address;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<UserStakingInfo, XAlphStakeVaultTypes.Maps>>;
        isStaking: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            user: Address;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<boolean, XAlphStakeVaultTypes.Maps>>;
        stake: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            amount: bigint;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>>;
        unstake: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            amount: bigint;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>>;
        connectToDapp: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            contractId: HexString;
            merkleProof: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>>;
        disconnectFromDapp: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            contractId: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>>;
        getWeight: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            user: Address;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<bigint, XAlphStakeVaultTypes.Maps>>;
        updateDappTemplatesWhitelistMerkleRoot: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            newMerkleRoot: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>>;
        updateOwner: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            newOwner: Address;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>>;
        verifyDappTemplatesWhiteListed: (params: TestContractParams<XAlphStakeVaultTypes.Fields, {
            proof: HexString;
            contractId: HexString;
        }, XAlphStakeVaultTypes.Maps>) => Promise<TestContractResult<boolean, XAlphStakeVaultTypes.Maps>>;
    };
    stateForTest(initFields: XAlphStakeVaultTypes.Fields, asset?: Asset, address?: string, maps?: XAlphStakeVaultTypes.Maps): ContractState<XAlphStakeVaultTypes.Fields> | _alephium_web3.ContractStateWithMaps<XAlphStakeVaultTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const XAlphStakeVault: Factory$b;
declare class XAlphStakeVaultInstance extends ContractInstance {
    constructor(address: Address);
    maps: {
        userStakingInfo: RalphMap<string, UserStakingInfo>;
    };
    fetchState(): Promise<XAlphStakeVaultTypes.State>;
    getContractEventsCurrentCount(): Promise<number>;
    subscribeUpdateRootEvent(options: EventSubscribeOptions<XAlphStakeVaultTypes.UpdateRootEvent>, fromCount?: number): EventSubscription;
    subscribeStakedEvent(options: EventSubscribeOptions<XAlphStakeVaultTypes.StakedEvent>, fromCount?: number): EventSubscription;
    subscribeUnstakedEvent(options: EventSubscribeOptions<XAlphStakeVaultTypes.UnstakedEvent>, fromCount?: number): EventSubscription;
    subscribeAllEvents(options: EventSubscribeOptions<XAlphStakeVaultTypes.UpdateRootEvent | XAlphStakeVaultTypes.StakedEvent | XAlphStakeVaultTypes.UnstakedEvent>, fromCount?: number): EventSubscription;
    view: {
        get: (params: XAlphStakeVaultTypes.CallMethodParams<"get">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"get">>;
        find: (params: XAlphStakeVaultTypes.CallMethodParams<"find">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"find">>;
        remove: (params: XAlphStakeVaultTypes.CallMethodParams<"remove">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"remove">>;
        push: (params: XAlphStakeVaultTypes.CallMethodParams<"push">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"push">>;
        removeAt: (params: XAlphStakeVaultTypes.CallMethodParams<"removeAt">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"removeAt">>;
        size: (params: XAlphStakeVaultTypes.CallMethodParams<"size">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"size">>;
        empty: (params?: XAlphStakeVaultTypes.CallMethodParams<"empty">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"empty">>;
        getMerkleRoot: (params?: XAlphStakeVaultTypes.CallMethodParams<"getMerkleRoot">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"getMerkleRoot">>;
        updateRoot: (params: XAlphStakeVaultTypes.CallMethodParams<"updateRoot">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"updateRoot">>;
        verify: (params: XAlphStakeVaultTypes.CallMethodParams<"verify">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"verify">>;
        hashPair: (params: XAlphStakeVaultTypes.CallMethodParams<"hashPair">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"hashPair">>;
        hash: (params: XAlphStakeVaultTypes.CallMethodParams<"hash">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"hash">>;
        getStakeTokenId: (params?: XAlphStakeVaultTypes.CallMethodParams<"getStakeTokenId">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"getStakeTokenId">>;
        getUserStakingInfo: (params: XAlphStakeVaultTypes.CallMethodParams<"getUserStakingInfo">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"getUserStakingInfo">>;
        isStaking: (params: XAlphStakeVaultTypes.CallMethodParams<"isStaking">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"isStaking">>;
        stake: (params: XAlphStakeVaultTypes.CallMethodParams<"stake">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"stake">>;
        unstake: (params: XAlphStakeVaultTypes.CallMethodParams<"unstake">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"unstake">>;
        connectToDapp: (params: XAlphStakeVaultTypes.CallMethodParams<"connectToDapp">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"connectToDapp">>;
        disconnectFromDapp: (params: XAlphStakeVaultTypes.CallMethodParams<"disconnectFromDapp">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"disconnectFromDapp">>;
        getWeight: (params: XAlphStakeVaultTypes.CallMethodParams<"getWeight">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"getWeight">>;
        updateDappTemplatesWhitelistMerkleRoot: (params: XAlphStakeVaultTypes.CallMethodParams<"updateDappTemplatesWhitelistMerkleRoot">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"updateDappTemplatesWhitelistMerkleRoot">>;
        updateOwner: (params: XAlphStakeVaultTypes.CallMethodParams<"updateOwner">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"updateOwner">>;
        verifyDappTemplatesWhiteListed: (params: XAlphStakeVaultTypes.CallMethodParams<"verifyDappTemplatesWhiteListed">) => Promise<XAlphStakeVaultTypes.CallMethodResult<"verifyDappTemplatesWhiteListed">>;
    };
    transact: {
        get: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"get">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"get">>;
        find: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"find">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"find">>;
        remove: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"remove">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"remove">>;
        push: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"push">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"push">>;
        removeAt: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"removeAt">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"removeAt">>;
        size: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"size">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"size">>;
        empty: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"empty">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"empty">>;
        getMerkleRoot: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"getMerkleRoot">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"getMerkleRoot">>;
        updateRoot: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"updateRoot">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"updateRoot">>;
        verify: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"verify">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"verify">>;
        hashPair: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"hashPair">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"hashPair">>;
        hash: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"hash">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"hash">>;
        getStakeTokenId: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"getStakeTokenId">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"getStakeTokenId">>;
        getUserStakingInfo: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"getUserStakingInfo">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"getUserStakingInfo">>;
        isStaking: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"isStaking">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"isStaking">>;
        stake: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"stake">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"stake">>;
        unstake: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"unstake">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"unstake">>;
        connectToDapp: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"connectToDapp">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"connectToDapp">>;
        disconnectFromDapp: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"disconnectFromDapp">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"disconnectFromDapp">>;
        getWeight: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"getWeight">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"getWeight">>;
        updateDappTemplatesWhitelistMerkleRoot: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"updateDappTemplatesWhitelistMerkleRoot">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"updateDappTemplatesWhitelistMerkleRoot">>;
        updateOwner: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"updateOwner">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"updateOwner">>;
        verifyDappTemplatesWhiteListed: (params: XAlphStakeVaultTypes.SignExecuteMethodParams<"verifyDappTemplatesWhiteListed">) => Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"verifyDappTemplatesWhiteListed">>;
    };
    multicall<Calls extends XAlphStakeVaultTypes.MultiCallParams>(calls: Calls): Promise<XAlphStakeVaultTypes.MultiCallResults<Calls>>;
    multicall<Callss extends XAlphStakeVaultTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<XAlphStakeVaultTypes.MulticallReturnType<Callss>>;
}

declare namespace XAlphTokenTypes {
    type Fields = {
        symbol: HexString;
        name: HexString;
        decimals: bigint;
        unstakeVaultTemplateId: HexString;
        maxActiveUnstakeRequestsPerUser: bigint;
        unstakeDuration: bigint;
        totalStaked: bigint;
        lastUnstakeVaultIndex: bigint;
    };
    type State = ContractState<Fields>;
    type StakedEvent = ContractEvent<{
        to: Address;
        amount: bigint;
    }>;
    type UnstakeScheduledEvent = ContractEvent<{
        to: Address;
        amount: bigint;
    }>;
    interface CallMethodTable {
        getSymbol: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getName: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getDecimals: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        getTotalSupply: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        get: {
            params: CallContractParams<{
                array: HexString;
                index: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        find: {
            params: CallContractParams<{
                array: HexString;
                value: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        remove: {
            params: CallContractParams<{
                array: HexString;
                value: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        push: {
            params: CallContractParams<{
                array: HexString;
                value: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        binarySearch: {
            params: CallContractParams<{
                array: HexString;
                value: bigint;
                left: bigint;
                right: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        removeAt: {
            params: CallContractParams<{
                array: HexString;
                index: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        size: {
            params: CallContractParams<{
                array: HexString;
            }>;
            result: CallContractResult<bigint>;
        };
        empty: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        stake: {
            params: CallContractParams<{
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        startUnstake: {
            params: CallContractParams<{
                amount: bigint;
            }>;
            result: CallContractResult<HexString>;
        };
        getActiveUnstakeVaultIndexes: {
            params: CallContractParams<{
                caller: Address;
            }>;
            result: CallContractResult<HexString>;
        };
        getClaimableAmount: {
            params: CallContractParams<{
                user: Address;
                vaultIndex: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        claimUnstaked: {
            params: CallContractParams<{
                vaultIndex: bigint;
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        getSymbol: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getName: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getDecimals: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getTotalSupply: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        get: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                index: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        find: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        remove: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        push: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        binarySearch: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                value: bigint;
                left: bigint;
                right: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        removeAt: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
                index: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        size: {
            params: SignExecuteContractMethodParams<{
                array: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        empty: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        stake: {
            params: SignExecuteContractMethodParams<{
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        startUnstake: {
            params: SignExecuteContractMethodParams<{
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getActiveUnstakeVaultIndexes: {
            params: SignExecuteContractMethodParams<{
                caller: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getClaimableAmount: {
            params: SignExecuteContractMethodParams<{
                user: Address;
                vaultIndex: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        claimUnstaked: {
            params: SignExecuteContractMethodParams<{
                vaultIndex: bigint;
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
    type Maps = {
        userActiveUnstakeVaults?: Map<Address, HexString>;
    };
}
declare class Factory$a extends ContractFactory<XAlphTokenInstance, XAlphTokenTypes.Fields> {
    encodeFields(fields: XAlphTokenTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    eventIndex: {
        Staked: number;
        UnstakeScheduled: number;
    };
    consts: {
        IntByteLength: bigint;
        ErrorCode: {
            InvalidArrayLength: bigint;
            IndexOutOfBound: bigint;
            InvalidByteVecLength: bigint;
        };
        ErrorCodes: {
            AssetAddressCallerOnly: bigint;
            TooManyActiveUnstakeVaults: bigint;
            InvalidUnstakeDuration: bigint;
            NonExistantUnstakeVault: bigint;
            AmountMustBeGreaterThanZero: bigint;
        };
    };
    at(address: string): XAlphTokenInstance;
    tests: {
        getSymbol: (params: Omit<TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>, "args">) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
        getName: (params: Omit<TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>, "args">) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
        getDecimals: (params: Omit<TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>, "args">) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
        getTotalSupply: (params: Omit<TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>, "args">) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
        get: (params: TestContractParams<XAlphTokenTypes.Fields, {
            array: HexString;
            index: bigint;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
        find: (params: TestContractParams<XAlphTokenTypes.Fields, {
            array: HexString;
            value: bigint;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
        remove: (params: TestContractParams<XAlphTokenTypes.Fields, {
            array: HexString;
            value: bigint;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
        push: (params: TestContractParams<XAlphTokenTypes.Fields, {
            array: HexString;
            value: bigint;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
        binarySearch: (params: TestContractParams<XAlphTokenTypes.Fields, {
            array: HexString;
            value: bigint;
            left: bigint;
            right: bigint;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
        removeAt: (params: TestContractParams<XAlphTokenTypes.Fields, {
            array: HexString;
            index: bigint;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
        size: (params: TestContractParams<XAlphTokenTypes.Fields, {
            array: HexString;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
        empty: (params: Omit<TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>, "args">) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
        stake: (params: TestContractParams<XAlphTokenTypes.Fields, {
            amount: bigint;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<null, XAlphTokenTypes.Maps>>;
        startUnstake: (params: TestContractParams<XAlphTokenTypes.Fields, {
            amount: bigint;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
        getActiveUnstakeVaultIndexes: (params: TestContractParams<XAlphTokenTypes.Fields, {
            caller: Address;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
        getClaimableAmount: (params: TestContractParams<XAlphTokenTypes.Fields, {
            user: Address;
            vaultIndex: bigint;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
        claimUnstaked: (params: TestContractParams<XAlphTokenTypes.Fields, {
            vaultIndex: bigint;
            amount: bigint;
        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<null, XAlphTokenTypes.Maps>>;
    };
    stateForTest(initFields: XAlphTokenTypes.Fields, asset?: Asset, address?: string, maps?: XAlphTokenTypes.Maps): ContractState<XAlphTokenTypes.Fields> | _alephium_web3.ContractStateWithMaps<XAlphTokenTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const XAlphToken: Factory$a;
declare class XAlphTokenInstance extends ContractInstance {
    constructor(address: Address);
    maps: {
        userActiveUnstakeVaults: RalphMap<string, string>;
    };
    fetchState(): Promise<XAlphTokenTypes.State>;
    getContractEventsCurrentCount(): Promise<number>;
    subscribeStakedEvent(options: EventSubscribeOptions<XAlphTokenTypes.StakedEvent>, fromCount?: number): EventSubscription;
    subscribeUnstakeScheduledEvent(options: EventSubscribeOptions<XAlphTokenTypes.UnstakeScheduledEvent>, fromCount?: number): EventSubscription;
    subscribeAllEvents(options: EventSubscribeOptions<XAlphTokenTypes.StakedEvent | XAlphTokenTypes.UnstakeScheduledEvent>, fromCount?: number): EventSubscription;
    view: {
        getSymbol: (params?: XAlphTokenTypes.CallMethodParams<"getSymbol">) => Promise<XAlphTokenTypes.CallMethodResult<"getSymbol">>;
        getName: (params?: XAlphTokenTypes.CallMethodParams<"getName">) => Promise<XAlphTokenTypes.CallMethodResult<"getName">>;
        getDecimals: (params?: XAlphTokenTypes.CallMethodParams<"getDecimals">) => Promise<XAlphTokenTypes.CallMethodResult<"getDecimals">>;
        getTotalSupply: (params?: XAlphTokenTypes.CallMethodParams<"getTotalSupply">) => Promise<XAlphTokenTypes.CallMethodResult<"getTotalSupply">>;
        get: (params: XAlphTokenTypes.CallMethodParams<"get">) => Promise<XAlphTokenTypes.CallMethodResult<"get">>;
        find: (params: XAlphTokenTypes.CallMethodParams<"find">) => Promise<XAlphTokenTypes.CallMethodResult<"find">>;
        remove: (params: XAlphTokenTypes.CallMethodParams<"remove">) => Promise<XAlphTokenTypes.CallMethodResult<"remove">>;
        push: (params: XAlphTokenTypes.CallMethodParams<"push">) => Promise<XAlphTokenTypes.CallMethodResult<"push">>;
        binarySearch: (params: XAlphTokenTypes.CallMethodParams<"binarySearch">) => Promise<XAlphTokenTypes.CallMethodResult<"binarySearch">>;
        removeAt: (params: XAlphTokenTypes.CallMethodParams<"removeAt">) => Promise<XAlphTokenTypes.CallMethodResult<"removeAt">>;
        size: (params: XAlphTokenTypes.CallMethodParams<"size">) => Promise<XAlphTokenTypes.CallMethodResult<"size">>;
        empty: (params?: XAlphTokenTypes.CallMethodParams<"empty">) => Promise<XAlphTokenTypes.CallMethodResult<"empty">>;
        stake: (params: XAlphTokenTypes.CallMethodParams<"stake">) => Promise<XAlphTokenTypes.CallMethodResult<"stake">>;
        startUnstake: (params: XAlphTokenTypes.CallMethodParams<"startUnstake">) => Promise<XAlphTokenTypes.CallMethodResult<"startUnstake">>;
        getActiveUnstakeVaultIndexes: (params: XAlphTokenTypes.CallMethodParams<"getActiveUnstakeVaultIndexes">) => Promise<XAlphTokenTypes.CallMethodResult<"getActiveUnstakeVaultIndexes">>;
        getClaimableAmount: (params: XAlphTokenTypes.CallMethodParams<"getClaimableAmount">) => Promise<XAlphTokenTypes.CallMethodResult<"getClaimableAmount">>;
        claimUnstaked: (params: XAlphTokenTypes.CallMethodParams<"claimUnstaked">) => Promise<XAlphTokenTypes.CallMethodResult<"claimUnstaked">>;
    };
    transact: {
        getSymbol: (params: XAlphTokenTypes.SignExecuteMethodParams<"getSymbol">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"getSymbol">>;
        getName: (params: XAlphTokenTypes.SignExecuteMethodParams<"getName">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"getName">>;
        getDecimals: (params: XAlphTokenTypes.SignExecuteMethodParams<"getDecimals">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"getDecimals">>;
        getTotalSupply: (params: XAlphTokenTypes.SignExecuteMethodParams<"getTotalSupply">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"getTotalSupply">>;
        get: (params: XAlphTokenTypes.SignExecuteMethodParams<"get">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"get">>;
        find: (params: XAlphTokenTypes.SignExecuteMethodParams<"find">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"find">>;
        remove: (params: XAlphTokenTypes.SignExecuteMethodParams<"remove">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"remove">>;
        push: (params: XAlphTokenTypes.SignExecuteMethodParams<"push">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"push">>;
        binarySearch: (params: XAlphTokenTypes.SignExecuteMethodParams<"binarySearch">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"binarySearch">>;
        removeAt: (params: XAlphTokenTypes.SignExecuteMethodParams<"removeAt">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"removeAt">>;
        size: (params: XAlphTokenTypes.SignExecuteMethodParams<"size">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"size">>;
        empty: (params: XAlphTokenTypes.SignExecuteMethodParams<"empty">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"empty">>;
        stake: (params: XAlphTokenTypes.SignExecuteMethodParams<"stake">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"stake">>;
        startUnstake: (params: XAlphTokenTypes.SignExecuteMethodParams<"startUnstake">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"startUnstake">>;
        getActiveUnstakeVaultIndexes: (params: XAlphTokenTypes.SignExecuteMethodParams<"getActiveUnstakeVaultIndexes">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"getActiveUnstakeVaultIndexes">>;
        getClaimableAmount: (params: XAlphTokenTypes.SignExecuteMethodParams<"getClaimableAmount">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"getClaimableAmount">>;
        claimUnstaked: (params: XAlphTokenTypes.SignExecuteMethodParams<"claimUnstaked">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"claimUnstaked">>;
    };
    multicall<Calls extends XAlphTokenTypes.MultiCallParams>(calls: Calls): Promise<XAlphTokenTypes.MultiCallResults<Calls>>;
    multicall<Callss extends XAlphTokenTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<XAlphTokenTypes.MulticallReturnType<Callss>>;
}

declare function getAllContracts$1(): ContractFactory<any>[];
declare function registerContract$1(factory: ContractFactory<any>): void;
declare function getContractByCodeHash$1(codeHash: string): Contract;

declare const AlphStakeAndLock: ExecutableScript<{
    xAlphToken: HexString;
    xAlphStakeVault: HexString;
    amount: bigint;
}, null>;
declare const XAlphUnlockAndStartUnstake: ExecutableScript<{
    xAlphToken: HexString;
    xAlphStakeVault: HexString;
    amount: bigint;
}, null>;

declare const index$1_AlphStakeAndLock: typeof AlphStakeAndLock;
declare const index$1_AlphUnstakeVault: typeof AlphUnstakeVault;
type index$1_AlphUnstakeVaultInstance = AlphUnstakeVaultInstance;
declare const index$1_AlphUnstakeVaultInstance: typeof AlphUnstakeVaultInstance;
declare const index$1_AlphUnstakeVaultTypes: typeof AlphUnstakeVaultTypes;
declare const index$1_GovernanceDemo: typeof GovernanceDemo;
type index$1_GovernanceDemoInstance = GovernanceDemoInstance;
declare const index$1_GovernanceDemoInstance: typeof GovernanceDemoInstance;
declare const index$1_GovernanceDemoTypes: typeof GovernanceDemoTypes;
declare const index$1_RewardSharingVault: typeof RewardSharingVault;
type index$1_RewardSharingVaultInstance = RewardSharingVaultInstance;
declare const index$1_RewardSharingVaultInstance: typeof RewardSharingVaultInstance;
declare const index$1_RewardSharingVaultTypes: typeof RewardSharingVaultTypes;
declare const index$1_TestDynamicArrayByteVec32: typeof TestDynamicArrayByteVec32;
type index$1_TestDynamicArrayByteVec32Instance = TestDynamicArrayByteVec32Instance;
declare const index$1_TestDynamicArrayByteVec32Instance: typeof TestDynamicArrayByteVec32Instance;
declare const index$1_TestDynamicArrayByteVec32Types: typeof TestDynamicArrayByteVec32Types;
declare const index$1_TestDynamicSortedArrayForU256: typeof TestDynamicSortedArrayForU256;
type index$1_TestDynamicSortedArrayForU256Instance = TestDynamicSortedArrayForU256Instance;
declare const index$1_TestDynamicSortedArrayForU256Instance: typeof TestDynamicSortedArrayForU256Instance;
declare const index$1_TestDynamicSortedArrayForU256Types: typeof TestDynamicSortedArrayForU256Types;
declare const index$1_TestMerkleProof: typeof TestMerkleProof;
type index$1_TestMerkleProofInstance = TestMerkleProofInstance;
declare const index$1_TestMerkleProofInstance: typeof TestMerkleProofInstance;
declare const index$1_TestMerkleProofTypes: typeof TestMerkleProofTypes;
declare const index$1_XAlphStakeVault: typeof XAlphStakeVault;
type index$1_XAlphStakeVaultInstance = XAlphStakeVaultInstance;
declare const index$1_XAlphStakeVaultInstance: typeof XAlphStakeVaultInstance;
declare const index$1_XAlphStakeVaultTypes: typeof XAlphStakeVaultTypes;
declare const index$1_XAlphToken: typeof XAlphToken;
type index$1_XAlphTokenInstance = XAlphTokenInstance;
declare const index$1_XAlphTokenInstance: typeof XAlphTokenInstance;
declare const index$1_XAlphTokenTypes: typeof XAlphTokenTypes;
declare const index$1_XAlphUnlockAndStartUnstake: typeof XAlphUnlockAndStartUnstake;
declare namespace index$1 {
  export { index$1_AlphStakeAndLock as AlphStakeAndLock, index$1_AlphUnstakeVault as AlphUnstakeVault, index$1_AlphUnstakeVaultInstance as AlphUnstakeVaultInstance, index$1_AlphUnstakeVaultTypes as AlphUnstakeVaultTypes, FullMathTest$1 as FullMathTest, FullMathTestInstance$1 as FullMathTestInstance, FullMathTestTypes$1 as FullMathTestTypes, index$1_GovernanceDemo as GovernanceDemo, index$1_GovernanceDemoInstance as GovernanceDemoInstance, index$1_GovernanceDemoTypes as GovernanceDemoTypes, index$1_RewardSharingVault as RewardSharingVault, index$1_RewardSharingVaultInstance as RewardSharingVaultInstance, index$1_RewardSharingVaultTypes as RewardSharingVaultTypes, index$1_TestDynamicArrayByteVec32 as TestDynamicArrayByteVec32, index$1_TestDynamicArrayByteVec32Instance as TestDynamicArrayByteVec32Instance, index$1_TestDynamicArrayByteVec32Types as TestDynamicArrayByteVec32Types, index$1_TestDynamicSortedArrayForU256 as TestDynamicSortedArrayForU256, index$1_TestDynamicSortedArrayForU256Instance as TestDynamicSortedArrayForU256Instance, index$1_TestDynamicSortedArrayForU256Types as TestDynamicSortedArrayForU256Types, index$1_TestMerkleProof as TestMerkleProof, index$1_TestMerkleProofInstance as TestMerkleProofInstance, index$1_TestMerkleProofTypes as TestMerkleProofTypes, index$1_XAlphStakeVault as XAlphStakeVault, index$1_XAlphStakeVaultInstance as XAlphStakeVaultInstance, index$1_XAlphStakeVaultTypes as XAlphStakeVaultTypes, index$1_XAlphToken as XAlphToken, index$1_XAlphTokenInstance as XAlphTokenInstance, index$1_XAlphTokenTypes as XAlphTokenTypes, index$1_XAlphUnlockAndStartUnstake as XAlphUnlockAndStartUnstake, getAllContracts$1 as getAllContracts, getContractByCodeHash$1 as getContractByCodeHash, registerContract$1 as registerContract };
}

interface StakingConfig {
    groupIndex: number;
    alphUnstakeVaultTemplateId: string;
    xAlphTokenId: string;
    xAlphTokenAddress: string;
    xAlphStakeVaultId: string;
    xAlphStakeVaultAddress: string;
    rewardSharingTemplateId?: string;
    governanceDemoTemplateId?: string;
}
interface StakeVaultUserInfo {
    amount: bigint;
    connectedDapps: string[];
}

type StakingSettings = {
    unstakeDuration: bigint;
    maxActiveUnstakeRequestsPerUser: bigint;
    maxConnectedDapps: bigint;
};
declare const stakingSettingsByNetwork: Record<NetworkId, StakingSettings>;
declare function getStakingSettings(networkId: NetworkId): StakingSettings;

declare class StakingModule extends ModuleBase {
    private config;
    private xAlphTokenContract;
    private stakeVaultContract;
    constructor(scope: Zeta);
    setConfig(config: StakingConfig): void;
    getConfig(): StakingConfig;
    getXAlphToken(): XAlphTokenInstance;
    getStakeVault(): XAlphStakeVaultInstance;
    getRewardSharingVault(contractId: string): RewardSharingVaultInstance;
    getGovernanceContract(contractId: string): GovernanceDemoInstance;
    getXAlphTokenState(): Promise<XAlphTokenTypes.State>;
    getStakeVaultState(): Promise<XAlphStakeVaultTypes.State>;
    stakeAlph(amount: bigint): Promise<XAlphTokenTypes.SignExecuteMethodResult<'stake'>>;
    startUnstake(amount: bigint): Promise<XAlphTokenTypes.SignExecuteMethodResult<'startUnstake'>>;
    claimUnstaked(vaultIndex: bigint, amount: bigint): Promise<XAlphTokenTypes.SignExecuteMethodResult<'claimUnstaked'>>;
    stakeXAlph(amount: bigint): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<'stake'>>;
    unstakeXAlph(amount: bigint): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<'unstake'>>;
    stakeAndLockAlph(amount: bigint): Promise<ExecuteScriptResult>;
    unlockAndStartUnstake(amount: bigint): Promise<ExecuteScriptResult>;
    getAlphUnstakeVault(userAddress: string, vaultIndex: bigint): AlphUnstakeVaultInstance;
    getAlphUnstakeVaultState(userAddress: string, vaultIndex: bigint): Promise<AlphUnstakeVaultTypes.State>;
    connectToDapp(contractId: string, merkleProof: HexString): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<'connectToDapp'>>;
    disconnectFromDapp(contractId: string): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<'disconnectFromDapp'>>;
    getUserStakeVaultInfo(address: string): Promise<StakeVaultUserInfo>;
    isUserStaking(address: string): Promise<boolean>;
    getUserWeight(address: string): Promise<bigint>;
    getActiveUnstakeVaultIndexes(address: string): Promise<bigint[]>;
    getClaimableAmount(address: string, vaultIndex: bigint): Promise<bigint>;
    getSettings(): StakingSettings;
    private loadStakingConfig;
    private ensurePositiveAmount;
}

declare class Zeta {
    cpmm: CpmmModule;
    clmm: ClmmModule;
    token: TokenModule;
    staking: StakingModule;
    private _nodeProvider;
    private _explorerProvider;
    private _tokenListUrl;
    private _signer?;
    private _account?;
    private _network;
    constructor(params: ZetaLoadParams);
    static load(config: ZetaLoadParams): Zeta;
    set signer(signer: SignerProvider);
    set account(account: Account);
    get signer(): SignerProvider;
    get account(): Account;
    clearSigner(): void;
    clearAccount(): void;
    get nodeProvider(): NodeProvider;
    get explorerProvider(): ExplorerProvider;
    get network(): Network;
    get tokenListUrl(): string;
    setCurrentProviders(): void;
}

declare const BPS = 10000n;

declare function sortTokens(tokenAId: string, tokenBId: string): [string, string];

declare class ZetaSDKError extends Error {
    constructor(message: string, options?: ErrorOptions);
}
declare class InsufficientLiquidityError extends ZetaSDKError {
    constructor(message?: string);
}
declare class PriceImpactTooHighError extends ZetaSDKError {
    constructor(priceImpact: number, maxPriceImpact: number);
}
declare class PoolNotFoundError extends ZetaSDKError {
    constructor(poolId: string);
}
declare class InsufficientBalanceError extends ZetaSDKError {
    constructor(token: string, required: string, available: string);
}
declare class TokenListFetchError extends ZetaSDKError {
    readonly status?: number;
    constructor(url: string, options?: {
        status?: number;
        cause?: unknown;
    });
}

type Rounding = 'floor' | 'ceil';
declare class MathUtil {
    static sqrt: (value: bigint) => bigint;
    static alphDiv(a: bigint, b: bigint): bigint;
    static alphCeil(a: bigint, b: bigint): bigint;
    static divFloor(a: bigint, b: bigint): bigint;
    static divCeil(a: bigint, b: bigint): bigint;
    static mulDivFloor(a: bigint, b: bigint, d: bigint): bigint;
    static mulDivCeil(a: bigint, b: bigint, d: bigint): bigint;
    private static divWithRounding;
}

type NumericLike = Decimal | bigint | number | string | undefined | null;
declare class NumericUtils {
    static decimalFrom(value: NumericLike): Decimal;
    static decimalToString(value: Decimal): string;
    static scaleDecimal(value: NumericLike, decimals: number): Decimal;
    static scaleToString(value: NumericLike, decimals: number): string;
    static numericToString(value: NumericLike): string;
    static numericToBigInt(value: NumericLike): bigint;
}

declare const MAX_PRICE_IMPACT = 5;
declare const MINIMUM_LIQUIDITY = 1000n;

declare class TickUtils {
    static getSqrtRatioAtTick(tick: bigint): bigint;
    static getTickAtSqrtRatio(sqrtPriceX96: bigint): bigint;
    static priceToSqrtPriceX96(price: Decimal.Value, token0Decimal: number, token1Decimal: number): bigint;
    static sqrtPriceX96ToPrice(sqrtPriceX96: bigint, token0Decimal: number, token1Decimal: number): number;
    static getAlignedTick(price: number, token0Decimal: number, token1Decimal: number, tickSpacing: bigint): bigint;
    static getNextTick(tick: bigint, tickSpacing: bigint, tokenBase: TokenInfo, tokenQuote: TokenInfo, baseIn: boolean, isAdd: boolean): bigint;
    static getAlignedPrice(priceIn: number, tokenBase: TokenInfo, tokenQuote: TokenInfo, tickSpacing: bigint, baseIn: boolean): {
        tick: bigint;
        price: number;
    };
    static getPriceFromTick(tick: bigint, tokenBase: TokenInfo, tokenQuote: TokenInfo, baseIn: boolean): {
        tick: bigint;
        price: number;
    };
    static getMinPriceFromTick(tokenBase: TokenInfo, tokenQuote: TokenInfo, tickSpacing: bigint, baseIn: boolean): {
        tick: bigint;
        price: number;
    };
    static getMaxPriceFromTick(tokenBase: TokenInfo, tokenQuote: TokenInfo, tickSpacing: bigint, baseIn: boolean): {
        tick: bigint;
        price: number;
    };
    static getNextSqrtPrice(sqrtPriceX96: bigint, liquidity: bigint, amount: bigint, zeroForOne: boolean): bigint;
    static getNextSqrtPriceFromAmount0(sqrtPriceX96: bigint, liquidity: bigint, amount: bigint): bigint;
    static getNextSqrtPriceFromAmount1(sqrtPriceX96: bigint, liquidity: bigint, amount: bigint): bigint;
    static getSqrtPriceLimitX96(sqrtPriceX96: bigint, slippage: bigint, zeroForOne: boolean): bigint;
    static getSqrtPriceX96Bounds(sqrtPriceX96: bigint, slippage: bigint): [bigint, bigint];
    private static priceSqrt;
}

declare const MIN_TICK: bigint;
declare const MAX_TICK: bigint;

declare const U256_MAX: bigint;
declare const UNLIMITED_AMOUNT: bigint;

declare class PoolUtils {
    static getPositionId(poolAddress: string, owner: string, tickLower: bigint, tickUpper: bigint): string;
    static computeSwapStep(sqrtPriceX96: bigint, sqrtPriceTargetX96: bigint, liquidity: bigint, amount: bigint, feePips: bigint): [bigint, bigint, bigint, bigint];
    static offlineSwap(liqDist: LiquidityDistribution, amountSpecified: bigint, sqrtPriceX96: bigint): bigint;
}

declare class ClmmLiquidityUtils {
    static getPositionAmountsFromPrice(p: GetPositionAmountsFromPriceProps): GetPositionAmountsFromPriceReturn;
    static getAmountsAndLiquidityAtPrice(currentPrice: number, token0: TokenInfo, token1: TokenInfo, lowerTick: bigint, upperTick: bigint, amount0: bigint, amount1: bigint): [bigint, bigint, bigint];
    static getAmountsAndLiquidityAtSqrtPrice(sqrtRatioX96: bigint, sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, amount0: bigint, amount1: bigint): [bigint, bigint, bigint];
    static getAmountsForLiquidity(sqrtRatioX96: bigint, sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): [bigint, bigint];
    static getLiquidityFromAmounts(sqrtRatioX96: bigint, sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, amount0: bigint, amount1: bigint): bigint;
    static getLiquidityFromToken0(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, amount0: bigint): bigint;
    static getLiquidityFromToken1(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, amount1: bigint): bigint;
    static getAmountDelta(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint, zeroForOne: boolean): bigint;
    static getToken0Delta(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): bigint;
    static getToken1Delta(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): bigint;
}

declare const decodeU256List: (str: string) => bigint[];
declare const decodeContractIdList: (str: string) => string[];

declare namespace TokenPairTypes {
    type Fields = {
        tokenPairFactory: HexString;
        token0Id: HexString;
        token1Id: HexString;
        dexAccount0: HexString;
        reserve0: bigint;
        reserve1: bigint;
        blockTimeStampLast: bigint;
        price0CumulativeLast: bigint;
        price1CumulativeLast: bigint;
        totalSupply: bigint;
        kLast: bigint;
        feeCollectorId: HexString;
    };
    type State = ContractState<Fields>;
    type MintEvent = ContractEvent<{
        sender: Address;
        amount0: bigint;
        amount1: bigint;
        liquidity: bigint;
        totalSupply: bigint;
    }>;
    type BurnEvent = ContractEvent<{
        sender: Address;
        amount0: bigint;
        amount1: bigint;
        liquidity: bigint;
        totalSupply: bigint;
    }>;
    type SwapEvent = ContractEvent<{
        sender: Address;
        amount0In: bigint;
        amount1In: bigint;
        amount0Out: bigint;
        amount1Out: bigint;
        to: Address;
    }>;
    interface CallMethodTable {
        getSymbol: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getName: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getDecimals: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        getTotalSupply: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        uqdiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        sqrt: {
            params: CallContractParams<{
                y: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        setFeeCollectorId: {
            params: CallContractParams<{
                id: HexString;
            }>;
            result: CallContractResult<null>;
        };
        getTokenPair: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<[HexString, HexString]>;
        };
        getReserves: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<[bigint, bigint]>;
        };
        getBlockTimeStampLast: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        getPrice0CumulativeLast: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        getPrice1CumulativeLast: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        update: {
            params: CallContractParams<{
                newReserve0: bigint;
                newReserve1: bigint;
            }>;
            result: CallContractResult<null>;
        };
        mintFee: {
            params: CallContractParams<{
                reserve0_: bigint;
                reserve1_: bigint;
            }>;
            result: CallContractResult<[boolean, bigint]>;
        };
        mint: {
            params: CallContractParams<{
                sender: Address;
                amount0: bigint;
                amount1: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        burn: {
            params: CallContractParams<{
                sender: Address;
                liquidity: bigint;
            }>;
            result: CallContractResult<[bigint, bigint]>;
        };
        swap: {
            params: CallContractParams<{
                sender: Address;
                to: Address;
                amount0In: bigint;
                amount1In: bigint;
                amount0Out: bigint;
                amount1Out: bigint;
            }>;
            result: CallContractResult<null>;
        };
        collectFeeManually: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<null>;
        };
        collectFeeAndUpdateKLast: {
            params: CallContractParams<{
                feeAmount: bigint;
            }>;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        getSymbol: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getName: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getDecimals: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getTotalSupply: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        uqdiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        sqrt: {
            params: SignExecuteContractMethodParams<{
                y: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        setFeeCollectorId: {
            params: SignExecuteContractMethodParams<{
                id: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getTokenPair: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getReserves: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getBlockTimeStampLast: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getPrice0CumulativeLast: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getPrice1CumulativeLast: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        update: {
            params: SignExecuteContractMethodParams<{
                newReserve0: bigint;
                newReserve1: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mintFee: {
            params: SignExecuteContractMethodParams<{
                reserve0_: bigint;
                reserve1_: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mint: {
            params: SignExecuteContractMethodParams<{
                sender: Address;
                amount0: bigint;
                amount1: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        burn: {
            params: SignExecuteContractMethodParams<{
                sender: Address;
                liquidity: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        swap: {
            params: SignExecuteContractMethodParams<{
                sender: Address;
                to: Address;
                amount0In: bigint;
                amount1In: bigint;
                amount0Out: bigint;
                amount1Out: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        collectFeeManually: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        collectFeeAndUpdateKLast: {
            params: SignExecuteContractMethodParams<{
                feeAmount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$9 extends ContractFactory<TokenPairInstance, TokenPairTypes.Fields> {
    encodeFields(fields: TokenPairTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    eventIndex: {
        Mint: number;
        Burn: number;
        Swap: number;
    };
    consts: {
        MINIMUM_LIQUIDITY: bigint;
        ErrorCodes: {
            ReserveOverflow: bigint;
            InsufficientInitLiquidity: bigint;
            InsufficientLiquidityMinted: bigint;
            InsufficientLiquidityBurned: bigint;
            InvalidToAddress: bigint;
            InsufficientLiquidity: bigint;
            InvalidTokenInId: bigint;
            InvalidCalleeId: bigint;
            InvalidK: bigint;
            InsufficientOutputAmount: bigint;
            InsufficientInputAmount: bigint;
            IdenticalTokenIds: bigint;
            Expired: bigint;
            InsufficientToken0Amount: bigint;
            InsufficientToken1Amount: bigint;
            TokenNotExist: bigint;
            InvalidCaller: bigint;
            FeeCollectorNotEnabled: bigint;
            InvalidAccount: bigint;
        };
    };
    at(address: string): TokenPairInstance;
    tests: {
        getSymbol: (params: Omit<TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<HexString>>;
        getName: (params: Omit<TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<HexString>>;
        getDecimals: (params: Omit<TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        getTotalSupply: (params: Omit<TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        uqdiv: (params: TestContractParamsWithoutMaps<TokenPairTypes.Fields, {
            a: bigint;
            b: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        sqrt: (params: TestContractParamsWithoutMaps<TokenPairTypes.Fields, {
            y: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        setFeeCollectorId: (params: TestContractParamsWithoutMaps<TokenPairTypes.Fields, {
            id: HexString;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        getTokenPair: (params: Omit<TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<[HexString, HexString]>>;
        getReserves: (params: Omit<TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        getBlockTimeStampLast: (params: Omit<TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        getPrice0CumulativeLast: (params: Omit<TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        getPrice1CumulativeLast: (params: Omit<TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        update: (params: TestContractParamsWithoutMaps<TokenPairTypes.Fields, {
            newReserve0: bigint;
            newReserve1: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        mintFee: (params: TestContractParamsWithoutMaps<TokenPairTypes.Fields, {
            reserve0_: bigint;
            reserve1_: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[boolean, bigint]>>;
        mint: (params: TestContractParamsWithoutMaps<TokenPairTypes.Fields, {
            sender: Address;
            amount0: bigint;
            amount1: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        burn: (params: TestContractParamsWithoutMaps<TokenPairTypes.Fields, {
            sender: Address;
            liquidity: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        swap: (params: TestContractParamsWithoutMaps<TokenPairTypes.Fields, {
            sender: Address;
            to: Address;
            amount0In: bigint;
            amount1In: bigint;
            amount0Out: bigint;
            amount1Out: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        collectFeeManually: (params: Omit<TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<null>>;
        collectFeeAndUpdateKLast: (params: TestContractParamsWithoutMaps<TokenPairTypes.Fields, {
            feeAmount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
    };
    stateForTest(initFields: TokenPairTypes.Fields, asset?: Asset, address?: string): ContractState<TokenPairTypes.Fields> | _alephium_web3.ContractStateWithMaps<TokenPairTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const TokenPair: Factory$9;
declare class TokenPairInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<TokenPairTypes.State>;
    getContractEventsCurrentCount(): Promise<number>;
    subscribeMintEvent(options: EventSubscribeOptions<TokenPairTypes.MintEvent>, fromCount?: number): EventSubscription;
    subscribeBurnEvent(options: EventSubscribeOptions<TokenPairTypes.BurnEvent>, fromCount?: number): EventSubscription;
    subscribeSwapEvent(options: EventSubscribeOptions<TokenPairTypes.SwapEvent>, fromCount?: number): EventSubscription;
    subscribeAllEvents(options: EventSubscribeOptions<TokenPairTypes.MintEvent | TokenPairTypes.BurnEvent | TokenPairTypes.SwapEvent>, fromCount?: number): EventSubscription;
    view: {
        getSymbol: (params?: TokenPairTypes.CallMethodParams<"getSymbol">) => Promise<TokenPairTypes.CallMethodResult<"getSymbol">>;
        getName: (params?: TokenPairTypes.CallMethodParams<"getName">) => Promise<TokenPairTypes.CallMethodResult<"getName">>;
        getDecimals: (params?: TokenPairTypes.CallMethodParams<"getDecimals">) => Promise<TokenPairTypes.CallMethodResult<"getDecimals">>;
        getTotalSupply: (params?: TokenPairTypes.CallMethodParams<"getTotalSupply">) => Promise<TokenPairTypes.CallMethodResult<"getTotalSupply">>;
        uqdiv: (params: TokenPairTypes.CallMethodParams<"uqdiv">) => Promise<TokenPairTypes.CallMethodResult<"uqdiv">>;
        sqrt: (params: TokenPairTypes.CallMethodParams<"sqrt">) => Promise<TokenPairTypes.CallMethodResult<"sqrt">>;
        setFeeCollectorId: (params: TokenPairTypes.CallMethodParams<"setFeeCollectorId">) => Promise<TokenPairTypes.CallMethodResult<"setFeeCollectorId">>;
        getTokenPair: (params?: TokenPairTypes.CallMethodParams<"getTokenPair">) => Promise<TokenPairTypes.CallMethodResult<"getTokenPair">>;
        getReserves: (params?: TokenPairTypes.CallMethodParams<"getReserves">) => Promise<TokenPairTypes.CallMethodResult<"getReserves">>;
        getBlockTimeStampLast: (params?: TokenPairTypes.CallMethodParams<"getBlockTimeStampLast">) => Promise<TokenPairTypes.CallMethodResult<"getBlockTimeStampLast">>;
        getPrice0CumulativeLast: (params?: TokenPairTypes.CallMethodParams<"getPrice0CumulativeLast">) => Promise<TokenPairTypes.CallMethodResult<"getPrice0CumulativeLast">>;
        getPrice1CumulativeLast: (params?: TokenPairTypes.CallMethodParams<"getPrice1CumulativeLast">) => Promise<TokenPairTypes.CallMethodResult<"getPrice1CumulativeLast">>;
        update: (params: TokenPairTypes.CallMethodParams<"update">) => Promise<TokenPairTypes.CallMethodResult<"update">>;
        mintFee: (params: TokenPairTypes.CallMethodParams<"mintFee">) => Promise<TokenPairTypes.CallMethodResult<"mintFee">>;
        mint: (params: TokenPairTypes.CallMethodParams<"mint">) => Promise<TokenPairTypes.CallMethodResult<"mint">>;
        burn: (params: TokenPairTypes.CallMethodParams<"burn">) => Promise<TokenPairTypes.CallMethodResult<"burn">>;
        swap: (params: TokenPairTypes.CallMethodParams<"swap">) => Promise<TokenPairTypes.CallMethodResult<"swap">>;
        collectFeeManually: (params?: TokenPairTypes.CallMethodParams<"collectFeeManually">) => Promise<TokenPairTypes.CallMethodResult<"collectFeeManually">>;
        collectFeeAndUpdateKLast: (params: TokenPairTypes.CallMethodParams<"collectFeeAndUpdateKLast">) => Promise<TokenPairTypes.CallMethodResult<"collectFeeAndUpdateKLast">>;
    };
    transact: {
        getSymbol: (params: TokenPairTypes.SignExecuteMethodParams<"getSymbol">) => Promise<TokenPairTypes.SignExecuteMethodResult<"getSymbol">>;
        getName: (params: TokenPairTypes.SignExecuteMethodParams<"getName">) => Promise<TokenPairTypes.SignExecuteMethodResult<"getName">>;
        getDecimals: (params: TokenPairTypes.SignExecuteMethodParams<"getDecimals">) => Promise<TokenPairTypes.SignExecuteMethodResult<"getDecimals">>;
        getTotalSupply: (params: TokenPairTypes.SignExecuteMethodParams<"getTotalSupply">) => Promise<TokenPairTypes.SignExecuteMethodResult<"getTotalSupply">>;
        uqdiv: (params: TokenPairTypes.SignExecuteMethodParams<"uqdiv">) => Promise<TokenPairTypes.SignExecuteMethodResult<"uqdiv">>;
        sqrt: (params: TokenPairTypes.SignExecuteMethodParams<"sqrt">) => Promise<TokenPairTypes.SignExecuteMethodResult<"sqrt">>;
        setFeeCollectorId: (params: TokenPairTypes.SignExecuteMethodParams<"setFeeCollectorId">) => Promise<TokenPairTypes.SignExecuteMethodResult<"setFeeCollectorId">>;
        getTokenPair: (params: TokenPairTypes.SignExecuteMethodParams<"getTokenPair">) => Promise<TokenPairTypes.SignExecuteMethodResult<"getTokenPair">>;
        getReserves: (params: TokenPairTypes.SignExecuteMethodParams<"getReserves">) => Promise<TokenPairTypes.SignExecuteMethodResult<"getReserves">>;
        getBlockTimeStampLast: (params: TokenPairTypes.SignExecuteMethodParams<"getBlockTimeStampLast">) => Promise<TokenPairTypes.SignExecuteMethodResult<"getBlockTimeStampLast">>;
        getPrice0CumulativeLast: (params: TokenPairTypes.SignExecuteMethodParams<"getPrice0CumulativeLast">) => Promise<TokenPairTypes.SignExecuteMethodResult<"getPrice0CumulativeLast">>;
        getPrice1CumulativeLast: (params: TokenPairTypes.SignExecuteMethodParams<"getPrice1CumulativeLast">) => Promise<TokenPairTypes.SignExecuteMethodResult<"getPrice1CumulativeLast">>;
        update: (params: TokenPairTypes.SignExecuteMethodParams<"update">) => Promise<TokenPairTypes.SignExecuteMethodResult<"update">>;
        mintFee: (params: TokenPairTypes.SignExecuteMethodParams<"mintFee">) => Promise<TokenPairTypes.SignExecuteMethodResult<"mintFee">>;
        mint: (params: TokenPairTypes.SignExecuteMethodParams<"mint">) => Promise<TokenPairTypes.SignExecuteMethodResult<"mint">>;
        burn: (params: TokenPairTypes.SignExecuteMethodParams<"burn">) => Promise<TokenPairTypes.SignExecuteMethodResult<"burn">>;
        swap: (params: TokenPairTypes.SignExecuteMethodParams<"swap">) => Promise<TokenPairTypes.SignExecuteMethodResult<"swap">>;
        collectFeeManually: (params: TokenPairTypes.SignExecuteMethodParams<"collectFeeManually">) => Promise<TokenPairTypes.SignExecuteMethodResult<"collectFeeManually">>;
        collectFeeAndUpdateKLast: (params: TokenPairTypes.SignExecuteMethodParams<"collectFeeAndUpdateKLast">) => Promise<TokenPairTypes.SignExecuteMethodResult<"collectFeeAndUpdateKLast">>;
    };
    multicall<Calls extends TokenPairTypes.MultiCallParams>(calls: Calls): Promise<TokenPairTypes.MultiCallResults<Calls>>;
    multicall<Callss extends TokenPairTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<TokenPairTypes.MulticallReturnType<Callss>>;
}

declare namespace TokenPairFactoryTypes {
    type Fields = {
        pairTemplateId: HexString;
        dexAccount0: HexString;
        pairSize: bigint;
        feeSetter: Address;
        feeCollectorFactory: HexString;
    };
    type State = ContractState<Fields>;
    type PairCreatedEvent = ContractEvent<{
        token0: HexString;
        token1: HexString;
        pair: HexString;
        currentPairSize: bigint;
    }>;
    interface CallMethodTable {
        setFeeCollectorFactory: {
            params: CallContractParams<{
                factory: HexString;
            }>;
            result: CallContractResult<null>;
        };
        updateFeeSetter: {
            params: CallContractParams<{
                newFeeSetter: Address;
            }>;
            result: CallContractResult<null>;
        };
        getFeeSetter: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<Address>;
        };
        enableFeeCollector: {
            params: CallContractParams<{
                tokenPair: HexString;
                alphAmount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        updateFeeCollector: {
            params: CallContractParams<{
                tokenPair: HexString;
                newFeeCollectorId: HexString;
            }>;
            result: CallContractResult<null>;
        };
        sortTokens: {
            params: CallContractParams<{
                tokenA: HexString;
                tokenB: HexString;
            }>;
            result: CallContractResult<[HexString, HexString]>;
        };
        createPair: {
            params: CallContractParams<{
                payer: Address;
                alphAmount: bigint;
                tokenAId: HexString;
                tokenBId: HexString;
            }>;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        setFeeCollectorFactory: {
            params: SignExecuteContractMethodParams<{
                factory: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        updateFeeSetter: {
            params: SignExecuteContractMethodParams<{
                newFeeSetter: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getFeeSetter: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        enableFeeCollector: {
            params: SignExecuteContractMethodParams<{
                tokenPair: HexString;
                alphAmount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        updateFeeCollector: {
            params: SignExecuteContractMethodParams<{
                tokenPair: HexString;
                newFeeCollectorId: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        sortTokens: {
            params: SignExecuteContractMethodParams<{
                tokenA: HexString;
                tokenB: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        createPair: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                alphAmount: bigint;
                tokenAId: HexString;
                tokenBId: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$8 extends ContractFactory<TokenPairFactoryInstance, TokenPairFactoryTypes.Fields> {
    encodeFields(fields: TokenPairFactoryTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    eventIndex: {
        PairCreated: number;
    };
    consts: {
        ErrorCodes: {
            ReserveOverflow: bigint;
            InsufficientInitLiquidity: bigint;
            InsufficientLiquidityMinted: bigint;
            InsufficientLiquidityBurned: bigint;
            InvalidToAddress: bigint;
            InsufficientLiquidity: bigint;
            InvalidTokenInId: bigint;
            InvalidCalleeId: bigint;
            InvalidK: bigint;
            InsufficientOutputAmount: bigint;
            InsufficientInputAmount: bigint;
            IdenticalTokenIds: bigint;
            Expired: bigint;
            InsufficientToken0Amount: bigint;
            InsufficientToken1Amount: bigint;
            TokenNotExist: bigint;
            InvalidCaller: bigint;
            FeeCollectorNotEnabled: bigint;
            InvalidAccount: bigint;
        };
    };
    at(address: string): TokenPairFactoryInstance;
    tests: {
        setFeeCollectorFactory: (params: TestContractParamsWithoutMaps<TokenPairFactoryTypes.Fields, {
            factory: HexString;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        updateFeeSetter: (params: TestContractParamsWithoutMaps<TokenPairFactoryTypes.Fields, {
            newFeeSetter: Address;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        getFeeSetter: (params: Omit<TestContractParamsWithoutMaps<TokenPairFactoryTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<Address>>;
        enableFeeCollector: (params: TestContractParamsWithoutMaps<TokenPairFactoryTypes.Fields, {
            tokenPair: HexString;
            alphAmount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        updateFeeCollector: (params: TestContractParamsWithoutMaps<TokenPairFactoryTypes.Fields, {
            tokenPair: HexString;
            newFeeCollectorId: HexString;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        sortTokens: (params: TestContractParamsWithoutMaps<TokenPairFactoryTypes.Fields, {
            tokenA: HexString;
            tokenB: HexString;
        }>) => Promise<TestContractResultWithoutMaps<[HexString, HexString]>>;
        createPair: (params: TestContractParamsWithoutMaps<TokenPairFactoryTypes.Fields, {
            payer: Address;
            alphAmount: bigint;
            tokenAId: HexString;
            tokenBId: HexString;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
    };
    stateForTest(initFields: TokenPairFactoryTypes.Fields, asset?: Asset, address?: string): ContractState<TokenPairFactoryTypes.Fields> | _alephium_web3.ContractStateWithMaps<TokenPairFactoryTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const TokenPairFactory: Factory$8;
declare class TokenPairFactoryInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<TokenPairFactoryTypes.State>;
    getContractEventsCurrentCount(): Promise<number>;
    subscribePairCreatedEvent(options: EventSubscribeOptions<TokenPairFactoryTypes.PairCreatedEvent>, fromCount?: number): EventSubscription;
    view: {
        setFeeCollectorFactory: (params: TokenPairFactoryTypes.CallMethodParams<"setFeeCollectorFactory">) => Promise<TokenPairFactoryTypes.CallMethodResult<"setFeeCollectorFactory">>;
        updateFeeSetter: (params: TokenPairFactoryTypes.CallMethodParams<"updateFeeSetter">) => Promise<TokenPairFactoryTypes.CallMethodResult<"updateFeeSetter">>;
        getFeeSetter: (params?: TokenPairFactoryTypes.CallMethodParams<"getFeeSetter">) => Promise<TokenPairFactoryTypes.CallMethodResult<"getFeeSetter">>;
        enableFeeCollector: (params: TokenPairFactoryTypes.CallMethodParams<"enableFeeCollector">) => Promise<TokenPairFactoryTypes.CallMethodResult<"enableFeeCollector">>;
        updateFeeCollector: (params: TokenPairFactoryTypes.CallMethodParams<"updateFeeCollector">) => Promise<TokenPairFactoryTypes.CallMethodResult<"updateFeeCollector">>;
        sortTokens: (params: TokenPairFactoryTypes.CallMethodParams<"sortTokens">) => Promise<TokenPairFactoryTypes.CallMethodResult<"sortTokens">>;
        createPair: (params: TokenPairFactoryTypes.CallMethodParams<"createPair">) => Promise<TokenPairFactoryTypes.CallMethodResult<"createPair">>;
    };
    transact: {
        setFeeCollectorFactory: (params: TokenPairFactoryTypes.SignExecuteMethodParams<"setFeeCollectorFactory">) => Promise<TokenPairFactoryTypes.SignExecuteMethodResult<"setFeeCollectorFactory">>;
        updateFeeSetter: (params: TokenPairFactoryTypes.SignExecuteMethodParams<"updateFeeSetter">) => Promise<TokenPairFactoryTypes.SignExecuteMethodResult<"updateFeeSetter">>;
        getFeeSetter: (params: TokenPairFactoryTypes.SignExecuteMethodParams<"getFeeSetter">) => Promise<TokenPairFactoryTypes.SignExecuteMethodResult<"getFeeSetter">>;
        enableFeeCollector: (params: TokenPairFactoryTypes.SignExecuteMethodParams<"enableFeeCollector">) => Promise<TokenPairFactoryTypes.SignExecuteMethodResult<"enableFeeCollector">>;
        updateFeeCollector: (params: TokenPairFactoryTypes.SignExecuteMethodParams<"updateFeeCollector">) => Promise<TokenPairFactoryTypes.SignExecuteMethodResult<"updateFeeCollector">>;
        sortTokens: (params: TokenPairFactoryTypes.SignExecuteMethodParams<"sortTokens">) => Promise<TokenPairFactoryTypes.SignExecuteMethodResult<"sortTokens">>;
        createPair: (params: TokenPairFactoryTypes.SignExecuteMethodParams<"createPair">) => Promise<TokenPairFactoryTypes.SignExecuteMethodResult<"createPair">>;
    };
    multicall<Calls extends TokenPairFactoryTypes.MultiCallParams>(calls: Calls): Promise<TokenPairFactoryTypes.MultiCallResults<Calls>>;
    multicall<Callss extends TokenPairFactoryTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<TokenPairFactoryTypes.MulticallReturnType<Callss>>;
}

declare namespace DexAccountTypes {
    type Fields = {
        parents: [HexString, HexString];
        owner: Address;
        refferer: Address;
        counter: bigint;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        deposit: {
            params: CallContractParams<{
                payer: Address;
                tokenId: HexString;
                amount: bigint;
                path: HexString;
                at: bigint;
            }>;
            result: CallContractResult<null>;
        };
        createAccount: {
            params: CallContractParams<{
                ref: Address;
            }>;
            result: CallContractResult<null>;
        };
        asRef: {
            params: CallContractParams<{
                defaultRef: Address;
            }>;
            result: CallContractResult<Address>;
        };
        updateCounter: {
            params: CallContractParams<{
                newCounter: bigint;
            }>;
            result: CallContractResult<null>;
        };
        setParents: {
            params: CallContractParams<{
                newParents: [HexString, HexString];
            }>;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        deposit: {
            params: SignExecuteContractMethodParams<{
                payer: Address;
                tokenId: HexString;
                amount: bigint;
                path: HexString;
                at: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        createAccount: {
            params: SignExecuteContractMethodParams<{
                ref: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        asRef: {
            params: SignExecuteContractMethodParams<{
                defaultRef: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        updateCounter: {
            params: SignExecuteContractMethodParams<{
                newCounter: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        setParents: {
            params: SignExecuteContractMethodParams<{
                newParents: [HexString, HexString];
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$7 extends ContractFactory<DexAccountInstance, DexAccountTypes.Fields> {
    encodeFields(fields: DexAccountTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    at(address: string): DexAccountInstance;
    tests: {
        deposit: (params: TestContractParamsWithoutMaps<DexAccountTypes.Fields, {
            payer: Address;
            tokenId: HexString;
            amount: bigint;
            path: HexString;
            at: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        createAccount: (params: TestContractParamsWithoutMaps<DexAccountTypes.Fields, {
            ref: Address;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        asRef: (params: TestContractParamsWithoutMaps<DexAccountTypes.Fields, {
            defaultRef: Address;
        }>) => Promise<TestContractResultWithoutMaps<Address>>;
        updateCounter: (params: TestContractParamsWithoutMaps<DexAccountTypes.Fields, {
            newCounter: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        setParents: (params: TestContractParamsWithoutMaps<DexAccountTypes.Fields, {
            newParents: [HexString, HexString];
        }>) => Promise<TestContractResultWithoutMaps<null>>;
    };
    stateForTest(initFields: DexAccountTypes.Fields, asset?: Asset, address?: string): ContractState<DexAccountTypes.Fields> | _alephium_web3.ContractStateWithMaps<DexAccountTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const DexAccount: Factory$7;
declare class DexAccountInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<DexAccountTypes.State>;
    view: {
        deposit: (params: DexAccountTypes.CallMethodParams<"deposit">) => Promise<DexAccountTypes.CallMethodResult<"deposit">>;
        createAccount: (params: DexAccountTypes.CallMethodParams<"createAccount">) => Promise<DexAccountTypes.CallMethodResult<"createAccount">>;
        asRef: (params: DexAccountTypes.CallMethodParams<"asRef">) => Promise<DexAccountTypes.CallMethodResult<"asRef">>;
        updateCounter: (params: DexAccountTypes.CallMethodParams<"updateCounter">) => Promise<DexAccountTypes.CallMethodResult<"updateCounter">>;
        setParents: (params: DexAccountTypes.CallMethodParams<"setParents">) => Promise<DexAccountTypes.CallMethodResult<"setParents">>;
    };
    transact: {
        deposit: (params: DexAccountTypes.SignExecuteMethodParams<"deposit">) => Promise<DexAccountTypes.SignExecuteMethodResult<"deposit">>;
        createAccount: (params: DexAccountTypes.SignExecuteMethodParams<"createAccount">) => Promise<DexAccountTypes.SignExecuteMethodResult<"createAccount">>;
        asRef: (params: DexAccountTypes.SignExecuteMethodParams<"asRef">) => Promise<DexAccountTypes.SignExecuteMethodResult<"asRef">>;
        updateCounter: (params: DexAccountTypes.SignExecuteMethodParams<"updateCounter">) => Promise<DexAccountTypes.SignExecuteMethodResult<"updateCounter">>;
        setParents: (params: DexAccountTypes.SignExecuteMethodParams<"setParents">) => Promise<DexAccountTypes.SignExecuteMethodResult<"setParents">>;
    };
    multicall<Calls extends DexAccountTypes.MultiCallParams>(calls: Calls): Promise<DexAccountTypes.MultiCallResults<Calls>>;
    multicall<Callss extends DexAccountTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<DexAccountTypes.MulticallReturnType<Callss>>;
}

declare namespace ExampleOracleSimpleTypes {
    type Fields = {
        pair: HexString;
        price0CumulativeLast: bigint;
        price1CumulativeLast: bigint;
        blockTimeStampLast: bigint;
        price0Average: bigint;
        price1Average: bigint;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        fullMul: {
            params: CallContractParams<{
                x: bigint;
                y: bigint;
            }>;
            result: CallContractResult<[bigint, bigint]>;
        };
        mulDiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        fraction: {
            params: CallContractParams<{
                numerator: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        currentCumulativePrices: {
            params: CallContractParams<{
                currentBlockTimeStamp: bigint;
            }>;
            result: CallContractResult<[bigint, bigint]>;
        };
        update: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<null>;
        };
        consult: {
            params: CallContractParams<{
                tokenId: HexString;
                amountIn: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        fullMul: {
            params: SignExecuteContractMethodParams<{
                x: bigint;
                y: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        fraction: {
            params: SignExecuteContractMethodParams<{
                numerator: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        currentCumulativePrices: {
            params: SignExecuteContractMethodParams<{
                currentBlockTimeStamp: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        update: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        consult: {
            params: SignExecuteContractMethodParams<{
                tokenId: HexString;
                amountIn: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$6 extends ContractFactory<ExampleOracleSimpleInstance, ExampleOracleSimpleTypes.Fields> {
    encodeFields(fields: ExampleOracleSimpleTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        Resolution: bigint;
        Period: bigint;
        ErrorCodes: {
            FullDivOverflow: bigint;
            DivByZero: bigint;
            FractionOverflow: bigint;
            PeriodNotElapsed: bigint;
            InvalidToken: bigint;
        };
    };
    at(address: string): ExampleOracleSimpleInstance;
    tests: {
        fullMul: (params: TestContractParamsWithoutMaps<ExampleOracleSimpleTypes.Fields, {
            x: bigint;
            y: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        mulDiv: (params: TestContractParamsWithoutMaps<ExampleOracleSimpleTypes.Fields, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        fraction: (params: TestContractParamsWithoutMaps<ExampleOracleSimpleTypes.Fields, {
            numerator: bigint;
            denominator: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
        currentCumulativePrices: (params: TestContractParamsWithoutMaps<ExampleOracleSimpleTypes.Fields, {
            currentBlockTimeStamp: bigint;
        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        update: (params: Omit<TestContractParamsWithoutMaps<ExampleOracleSimpleTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<null>>;
        consult: (params: TestContractParamsWithoutMaps<ExampleOracleSimpleTypes.Fields, {
            tokenId: HexString;
            amountIn: bigint;
        }>) => Promise<TestContractResultWithoutMaps<bigint>>;
    };
    stateForTest(initFields: ExampleOracleSimpleTypes.Fields, asset?: Asset, address?: string): ContractState<ExampleOracleSimpleTypes.Fields> | _alephium_web3.ContractStateWithMaps<ExampleOracleSimpleTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const ExampleOracleSimple: Factory$6;
declare class ExampleOracleSimpleInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<ExampleOracleSimpleTypes.State>;
    view: {
        fullMul: (params: ExampleOracleSimpleTypes.CallMethodParams<"fullMul">) => Promise<ExampleOracleSimpleTypes.CallMethodResult<"fullMul">>;
        mulDiv: (params: ExampleOracleSimpleTypes.CallMethodParams<"mulDiv">) => Promise<ExampleOracleSimpleTypes.CallMethodResult<"mulDiv">>;
        fraction: (params: ExampleOracleSimpleTypes.CallMethodParams<"fraction">) => Promise<ExampleOracleSimpleTypes.CallMethodResult<"fraction">>;
        currentCumulativePrices: (params: ExampleOracleSimpleTypes.CallMethodParams<"currentCumulativePrices">) => Promise<ExampleOracleSimpleTypes.CallMethodResult<"currentCumulativePrices">>;
        update: (params?: ExampleOracleSimpleTypes.CallMethodParams<"update">) => Promise<ExampleOracleSimpleTypes.CallMethodResult<"update">>;
        consult: (params: ExampleOracleSimpleTypes.CallMethodParams<"consult">) => Promise<ExampleOracleSimpleTypes.CallMethodResult<"consult">>;
    };
    transact: {
        fullMul: (params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"fullMul">) => Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"fullMul">>;
        mulDiv: (params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"mulDiv">) => Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"mulDiv">>;
        fraction: (params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"fraction">) => Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"fraction">>;
        currentCumulativePrices: (params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"currentCumulativePrices">) => Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"currentCumulativePrices">>;
        update: (params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"update">) => Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"update">>;
        consult: (params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"consult">) => Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"consult">>;
    };
    multicall<Calls extends ExampleOracleSimpleTypes.MultiCallParams>(calls: Calls): Promise<ExampleOracleSimpleTypes.MultiCallResults<Calls>>;
    multicall<Callss extends ExampleOracleSimpleTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<ExampleOracleSimpleTypes.MulticallReturnType<Callss>>;
}

declare namespace FeeCollectorFactoryImplTypes {
    type Fields = {
        feeCollectorPerTokenPairTemplateId: HexString;
        tokenPairFactory: HexString;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        createFeeCollector: {
            params: CallContractParams<{
                caller: Address;
                alphAmount: bigint;
                tokenPair: HexString;
            }>;
            result: CallContractResult<HexString>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        createFeeCollector: {
            params: SignExecuteContractMethodParams<{
                caller: Address;
                alphAmount: bigint;
                tokenPair: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$5 extends ContractFactory<FeeCollectorFactoryImplInstance, FeeCollectorFactoryImplTypes.Fields> {
    encodeFields(fields: FeeCollectorFactoryImplTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        ErrorCodes: {
            ReserveOverflow: bigint;
            InsufficientInitLiquidity: bigint;
            InsufficientLiquidityMinted: bigint;
            InsufficientLiquidityBurned: bigint;
            InvalidToAddress: bigint;
            InsufficientLiquidity: bigint;
            InvalidTokenInId: bigint;
            InvalidCalleeId: bigint;
            InvalidK: bigint;
            InsufficientOutputAmount: bigint;
            InsufficientInputAmount: bigint;
            IdenticalTokenIds: bigint;
            Expired: bigint;
            InsufficientToken0Amount: bigint;
            InsufficientToken1Amount: bigint;
            TokenNotExist: bigint;
            InvalidCaller: bigint;
            FeeCollectorNotEnabled: bigint;
            InvalidAccount: bigint;
        };
    };
    at(address: string): FeeCollectorFactoryImplInstance;
    tests: {
        createFeeCollector: (params: TestContractParamsWithoutMaps<FeeCollectorFactoryImplTypes.Fields, {
            caller: Address;
            alphAmount: bigint;
            tokenPair: HexString;
        }>) => Promise<TestContractResultWithoutMaps<HexString>>;
    };
    stateForTest(initFields: FeeCollectorFactoryImplTypes.Fields, asset?: Asset, address?: string): ContractState<FeeCollectorFactoryImplTypes.Fields> | _alephium_web3.ContractStateWithMaps<FeeCollectorFactoryImplTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const FeeCollectorFactoryImpl: Factory$5;
declare class FeeCollectorFactoryImplInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<FeeCollectorFactoryImplTypes.State>;
    view: {
        createFeeCollector: (params: FeeCollectorFactoryImplTypes.CallMethodParams<"createFeeCollector">) => Promise<FeeCollectorFactoryImplTypes.CallMethodResult<"createFeeCollector">>;
    };
    transact: {
        createFeeCollector: (params: FeeCollectorFactoryImplTypes.SignExecuteMethodParams<"createFeeCollector">) => Promise<FeeCollectorFactoryImplTypes.SignExecuteMethodResult<"createFeeCollector">>;
    };
    multicall<Calls extends FeeCollectorFactoryImplTypes.MultiCallParams>(calls: Calls): Promise<FeeCollectorFactoryImplTypes.MultiCallResults<Calls>>;
    multicall<Callss extends FeeCollectorFactoryImplTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<FeeCollectorFactoryImplTypes.MulticallReturnType<Callss>>;
}

declare namespace FeeCollectorPerTokenPairImplTypes {
    type Fields = {
        tokenPairFactory: HexString;
        tokenPair: HexString;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        collectFee: {
            params: CallContractParams<{
                from: Address;
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        withdraw: {
            params: CallContractParams<{
                to: Address;
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
        destroy: {
            params: CallContractParams<{
                to: Address;
            }>;
            result: CallContractResult<null>;
        };
        collectFeeManually: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        collectFee: {
            params: SignExecuteContractMethodParams<{
                from: Address;
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        withdraw: {
            params: SignExecuteContractMethodParams<{
                to: Address;
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        destroy: {
            params: SignExecuteContractMethodParams<{
                to: Address;
            }>;
            result: SignExecuteScriptTxResult;
        };
        collectFeeManually: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$4 extends ContractFactory<FeeCollectorPerTokenPairImplInstance, FeeCollectorPerTokenPairImplTypes.Fields> {
    encodeFields(fields: FeeCollectorPerTokenPairImplTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        ErrorCodes: {
            ReserveOverflow: bigint;
            InsufficientInitLiquidity: bigint;
            InsufficientLiquidityMinted: bigint;
            InsufficientLiquidityBurned: bigint;
            InvalidToAddress: bigint;
            InsufficientLiquidity: bigint;
            InvalidTokenInId: bigint;
            InvalidCalleeId: bigint;
            InvalidK: bigint;
            InsufficientOutputAmount: bigint;
            InsufficientInputAmount: bigint;
            IdenticalTokenIds: bigint;
            Expired: bigint;
            InsufficientToken0Amount: bigint;
            InsufficientToken1Amount: bigint;
            TokenNotExist: bigint;
            InvalidCaller: bigint;
            FeeCollectorNotEnabled: bigint;
            InvalidAccount: bigint;
        };
    };
    at(address: string): FeeCollectorPerTokenPairImplInstance;
    tests: {
        collectFee: (params: TestContractParamsWithoutMaps<FeeCollectorPerTokenPairImplTypes.Fields, {
            from: Address;
            amount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        withdraw: (params: TestContractParamsWithoutMaps<FeeCollectorPerTokenPairImplTypes.Fields, {
            to: Address;
            amount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        destroy: (params: TestContractParamsWithoutMaps<FeeCollectorPerTokenPairImplTypes.Fields, {
            to: Address;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
        collectFeeManually: (params: Omit<TestContractParamsWithoutMaps<FeeCollectorPerTokenPairImplTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<null>>;
    };
    stateForTest(initFields: FeeCollectorPerTokenPairImplTypes.Fields, asset?: Asset, address?: string): ContractState<FeeCollectorPerTokenPairImplTypes.Fields> | _alephium_web3.ContractStateWithMaps<FeeCollectorPerTokenPairImplTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const FeeCollectorPerTokenPairImpl: Factory$4;
declare class FeeCollectorPerTokenPairImplInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<FeeCollectorPerTokenPairImplTypes.State>;
    view: {
        collectFee: (params: FeeCollectorPerTokenPairImplTypes.CallMethodParams<"collectFee">) => Promise<FeeCollectorPerTokenPairImplTypes.CallMethodResult<"collectFee">>;
        withdraw: (params: FeeCollectorPerTokenPairImplTypes.CallMethodParams<"withdraw">) => Promise<FeeCollectorPerTokenPairImplTypes.CallMethodResult<"withdraw">>;
        destroy: (params: FeeCollectorPerTokenPairImplTypes.CallMethodParams<"destroy">) => Promise<FeeCollectorPerTokenPairImplTypes.CallMethodResult<"destroy">>;
        collectFeeManually: (params?: FeeCollectorPerTokenPairImplTypes.CallMethodParams<"collectFeeManually">) => Promise<FeeCollectorPerTokenPairImplTypes.CallMethodResult<"collectFeeManually">>;
    };
    transact: {
        collectFee: (params: FeeCollectorPerTokenPairImplTypes.SignExecuteMethodParams<"collectFee">) => Promise<FeeCollectorPerTokenPairImplTypes.SignExecuteMethodResult<"collectFee">>;
        withdraw: (params: FeeCollectorPerTokenPairImplTypes.SignExecuteMethodParams<"withdraw">) => Promise<FeeCollectorPerTokenPairImplTypes.SignExecuteMethodResult<"withdraw">>;
        destroy: (params: FeeCollectorPerTokenPairImplTypes.SignExecuteMethodParams<"destroy">) => Promise<FeeCollectorPerTokenPairImplTypes.SignExecuteMethodResult<"destroy">>;
        collectFeeManually: (params: FeeCollectorPerTokenPairImplTypes.SignExecuteMethodParams<"collectFeeManually">) => Promise<FeeCollectorPerTokenPairImplTypes.SignExecuteMethodResult<"collectFeeManually">>;
    };
}

declare namespace FullMathTestTypes {
    type State = Omit<ContractState<any>, "fields">;
    interface CallMethodTable {
        fullMul: {
            params: CallContractParams<{
                x: bigint;
                y: bigint;
            }>;
            result: CallContractResult<[bigint, bigint]>;
        };
        mulDiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        fraction: {
            params: CallContractParams<{
                numerator: bigint;
                denominator: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        fullMul: {
            params: SignExecuteContractMethodParams<{
                x: bigint;
                y: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        mulDiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        fraction: {
            params: SignExecuteContractMethodParams<{
                numerator: bigint;
                denominator: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$3 extends ContractFactory<FullMathTestInstance, {}> {
    encodeFields(): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        Resolution: bigint;
        ErrorCodes: {
            FullDivOverflow: bigint;
            DivByZero: bigint;
            FractionOverflow: bigint;
            PeriodNotElapsed: bigint;
            InvalidToken: bigint;
        };
    };
    at(address: string): FullMathTestInstance;
    tests: {
        fullMul: (params: Omit<TestContractParamsWithoutMaps<never, {
            x: bigint;
            y: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        mulDiv: (params: Omit<TestContractParamsWithoutMaps<never, {
            a: bigint;
            b: bigint;
            denominator: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        fraction: (params: Omit<TestContractParamsWithoutMaps<never, {
            numerator: bigint;
            denominator: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
    };
    stateForTest(initFields: {}, asset?: Asset, address?: string): ContractState<{}> | _alephium_web3.ContractStateWithMaps<{}, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const FullMathTest: Factory$3;
declare class FullMathTestInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<FullMathTestTypes.State>;
    view: {
        fullMul: (params: FullMathTestTypes.CallMethodParams<"fullMul">) => Promise<FullMathTestTypes.CallMethodResult<"fullMul">>;
        mulDiv: (params: FullMathTestTypes.CallMethodParams<"mulDiv">) => Promise<FullMathTestTypes.CallMethodResult<"mulDiv">>;
        fraction: (params: FullMathTestTypes.CallMethodParams<"fraction">) => Promise<FullMathTestTypes.CallMethodResult<"fraction">>;
    };
    transact: {
        fullMul: (params: FullMathTestTypes.SignExecuteMethodParams<"fullMul">) => Promise<FullMathTestTypes.SignExecuteMethodResult<"fullMul">>;
        mulDiv: (params: FullMathTestTypes.SignExecuteMethodParams<"mulDiv">) => Promise<FullMathTestTypes.SignExecuteMethodResult<"mulDiv">>;
        fraction: (params: FullMathTestTypes.SignExecuteMethodParams<"fraction">) => Promise<FullMathTestTypes.SignExecuteMethodResult<"fraction">>;
    };
    multicall<Calls extends FullMathTestTypes.MultiCallParams>(calls: Calls): Promise<FullMathTestTypes.MultiCallResults<Calls>>;
    multicall<Callss extends FullMathTestTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<FullMathTestTypes.MulticallReturnType<Callss>>;
}

declare namespace MathTestTypes {
    type State = Omit<ContractState<any>, "fields">;
    interface CallMethodTable {
        uqdiv: {
            params: CallContractParams<{
                a: bigint;
                b: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
        sqrt: {
            params: CallContractParams<{
                y: bigint;
            }>;
            result: CallContractResult<bigint>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        uqdiv: {
            params: SignExecuteContractMethodParams<{
                a: bigint;
                b: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        sqrt: {
            params: SignExecuteContractMethodParams<{
                y: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$2 extends ContractFactory<MathTestInstance, {}> {
    encodeFields(): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    at(address: string): MathTestInstance;
    tests: {
        uqdiv: (params: Omit<TestContractParamsWithoutMaps<never, {
            a: bigint;
            b: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
        sqrt: (params: Omit<TestContractParamsWithoutMaps<never, {
            y: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<bigint>>;
    };
    stateForTest(initFields: {}, asset?: Asset, address?: string): ContractState<{}> | _alephium_web3.ContractStateWithMaps<{}, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const MathTest: Factory$2;
declare class MathTestInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<MathTestTypes.State>;
    view: {
        uqdiv: (params: MathTestTypes.CallMethodParams<"uqdiv">) => Promise<MathTestTypes.CallMethodResult<"uqdiv">>;
        sqrt: (params: MathTestTypes.CallMethodParams<"sqrt">) => Promise<MathTestTypes.CallMethodResult<"sqrt">>;
    };
    transact: {
        uqdiv: (params: MathTestTypes.SignExecuteMethodParams<"uqdiv">) => Promise<MathTestTypes.SignExecuteMethodResult<"uqdiv">>;
        sqrt: (params: MathTestTypes.SignExecuteMethodParams<"sqrt">) => Promise<MathTestTypes.SignExecuteMethodResult<"sqrt">>;
    };
    multicall<Calls extends MathTestTypes.MultiCallParams>(calls: Calls): Promise<MathTestTypes.MultiCallResults<Calls>>;
    multicall<Callss extends MathTestTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<MathTestTypes.MulticallReturnType<Callss>>;
}

declare namespace RouterTypes {
    type State = Omit<ContractState<any>, "fields">;
    interface CallMethodTable {
        addLiquidity_: {
            params: CallContractParams<{
                reserve0: bigint;
                reserve1: bigint;
                amount0Desired: bigint;
                amount1Desired: bigint;
                amount0Min: bigint;
                amount1Min: bigint;
            }>;
            result: CallContractResult<[bigint, bigint]>;
        };
        addLiquidity: {
            params: CallContractParams<{
                tokenPair: HexString;
                sender: Address;
                amount0Desired: bigint;
                amount1Desired: bigint;
                amount0Min: bigint;
                amount1Min: bigint;
                deadline: bigint;
            }>;
            result: CallContractResult<[bigint, bigint, bigint]>;
        };
        removeLiquidity: {
            params: CallContractParams<{
                tokenPairId: HexString;
                sender: Address;
                liquidity: bigint;
                amount0Min: bigint;
                amount1Min: bigint;
                deadline: bigint;
            }>;
            result: CallContractResult<[bigint, bigint]>;
        };
        getReserveInAndReserveOut: {
            params: CallContractParams<{
                tokenPair: HexString;
                tokenInId: HexString;
            }>;
            result: CallContractResult<[bigint, bigint]>;
        };
        swapExactTokenForToken: {
            params: CallContractParams<{
                tokenPair: HexString;
                sender: Address;
                tokenInId: HexString;
                amountIn: bigint;
                amountOutMin: bigint;
                to: Address;
                deadline: bigint;
            }>;
            result: CallContractResult<null>;
        };
        swapTokenForExactToken: {
            params: CallContractParams<{
                tokenPair: HexString;
                sender: Address;
                tokenInId: HexString;
                amountInMax: bigint;
                amountOut: bigint;
                to: Address;
                deadline: bigint;
            }>;
            result: CallContractResult<null>;
        };
        swap: {
            params: CallContractParams<{
                tokenPair: HexString;
                sender: Address;
                to: Address;
                tokenInId: HexString;
                amountIn: bigint;
                amountOut: bigint;
            }>;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        addLiquidity_: {
            params: SignExecuteContractMethodParams<{
                reserve0: bigint;
                reserve1: bigint;
                amount0Desired: bigint;
                amount1Desired: bigint;
                amount0Min: bigint;
                amount1Min: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        addLiquidity: {
            params: SignExecuteContractMethodParams<{
                tokenPair: HexString;
                sender: Address;
                amount0Desired: bigint;
                amount1Desired: bigint;
                amount0Min: bigint;
                amount1Min: bigint;
                deadline: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        removeLiquidity: {
            params: SignExecuteContractMethodParams<{
                tokenPairId: HexString;
                sender: Address;
                liquidity: bigint;
                amount0Min: bigint;
                amount1Min: bigint;
                deadline: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        getReserveInAndReserveOut: {
            params: SignExecuteContractMethodParams<{
                tokenPair: HexString;
                tokenInId: HexString;
            }>;
            result: SignExecuteScriptTxResult;
        };
        swapExactTokenForToken: {
            params: SignExecuteContractMethodParams<{
                tokenPair: HexString;
                sender: Address;
                tokenInId: HexString;
                amountIn: bigint;
                amountOutMin: bigint;
                to: Address;
                deadline: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        swapTokenForExactToken: {
            params: SignExecuteContractMethodParams<{
                tokenPair: HexString;
                sender: Address;
                tokenInId: HexString;
                amountInMax: bigint;
                amountOut: bigint;
                to: Address;
                deadline: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
        swap: {
            params: SignExecuteContractMethodParams<{
                tokenPair: HexString;
                sender: Address;
                to: Address;
                tokenInId: HexString;
                amountIn: bigint;
                amountOut: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory$1 extends ContractFactory<RouterInstance, {}> {
    encodeFields(): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    consts: {
        ErrorCodes: {
            ReserveOverflow: bigint;
            InsufficientInitLiquidity: bigint;
            InsufficientLiquidityMinted: bigint;
            InsufficientLiquidityBurned: bigint;
            InvalidToAddress: bigint;
            InsufficientLiquidity: bigint;
            InvalidTokenInId: bigint;
            InvalidCalleeId: bigint;
            InvalidK: bigint;
            InsufficientOutputAmount: bigint;
            InsufficientInputAmount: bigint;
            IdenticalTokenIds: bigint;
            Expired: bigint;
            InsufficientToken0Amount: bigint;
            InsufficientToken1Amount: bigint;
            TokenNotExist: bigint;
            InvalidCaller: bigint;
            FeeCollectorNotEnabled: bigint;
            InvalidAccount: bigint;
        };
    };
    at(address: string): RouterInstance;
    tests: {
        addLiquidity_: (params: Omit<TestContractParamsWithoutMaps<never, {
            reserve0: bigint;
            reserve1: bigint;
            amount0Desired: bigint;
            amount1Desired: bigint;
            amount0Min: bigint;
            amount1Min: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        addLiquidity: (params: Omit<TestContractParamsWithoutMaps<never, {
            tokenPair: HexString;
            sender: Address;
            amount0Desired: bigint;
            amount1Desired: bigint;
            amount0Min: bigint;
            amount1Min: bigint;
            deadline: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
        removeLiquidity: (params: Omit<TestContractParamsWithoutMaps<never, {
            tokenPairId: HexString;
            sender: Address;
            liquidity: bigint;
            amount0Min: bigint;
            amount1Min: bigint;
            deadline: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        getReserveInAndReserveOut: (params: Omit<TestContractParamsWithoutMaps<never, {
            tokenPair: HexString;
            tokenInId: HexString;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
        swapExactTokenForToken: (params: Omit<TestContractParamsWithoutMaps<never, {
            tokenPair: HexString;
            sender: Address;
            tokenInId: HexString;
            amountIn: bigint;
            amountOutMin: bigint;
            to: Address;
            deadline: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<null>>;
        swapTokenForExactToken: (params: Omit<TestContractParamsWithoutMaps<never, {
            tokenPair: HexString;
            sender: Address;
            tokenInId: HexString;
            amountInMax: bigint;
            amountOut: bigint;
            to: Address;
            deadline: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<null>>;
        swap: (params: Omit<TestContractParamsWithoutMaps<never, {
            tokenPair: HexString;
            sender: Address;
            to: Address;
            tokenInId: HexString;
            amountIn: bigint;
            amountOut: bigint;
        }>, "initialFields">) => Promise<TestContractResultWithoutMaps<null>>;
    };
    stateForTest(initFields: {}, asset?: Asset, address?: string): ContractState<{}> | _alephium_web3.ContractStateWithMaps<{}, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const Router: Factory$1;
declare class RouterInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<RouterTypes.State>;
    view: {
        addLiquidity_: (params: RouterTypes.CallMethodParams<"addLiquidity_">) => Promise<RouterTypes.CallMethodResult<"addLiquidity_">>;
        addLiquidity: (params: RouterTypes.CallMethodParams<"addLiquidity">) => Promise<RouterTypes.CallMethodResult<"addLiquidity">>;
        removeLiquidity: (params: RouterTypes.CallMethodParams<"removeLiquidity">) => Promise<RouterTypes.CallMethodResult<"removeLiquidity">>;
        getReserveInAndReserveOut: (params: RouterTypes.CallMethodParams<"getReserveInAndReserveOut">) => Promise<RouterTypes.CallMethodResult<"getReserveInAndReserveOut">>;
        swapExactTokenForToken: (params: RouterTypes.CallMethodParams<"swapExactTokenForToken">) => Promise<RouterTypes.CallMethodResult<"swapExactTokenForToken">>;
        swapTokenForExactToken: (params: RouterTypes.CallMethodParams<"swapTokenForExactToken">) => Promise<RouterTypes.CallMethodResult<"swapTokenForExactToken">>;
        swap: (params: RouterTypes.CallMethodParams<"swap">) => Promise<RouterTypes.CallMethodResult<"swap">>;
    };
    transact: {
        addLiquidity_: (params: RouterTypes.SignExecuteMethodParams<"addLiquidity_">) => Promise<RouterTypes.SignExecuteMethodResult<"addLiquidity_">>;
        addLiquidity: (params: RouterTypes.SignExecuteMethodParams<"addLiquidity">) => Promise<RouterTypes.SignExecuteMethodResult<"addLiquidity">>;
        removeLiquidity: (params: RouterTypes.SignExecuteMethodParams<"removeLiquidity">) => Promise<RouterTypes.SignExecuteMethodResult<"removeLiquidity">>;
        getReserveInAndReserveOut: (params: RouterTypes.SignExecuteMethodParams<"getReserveInAndReserveOut">) => Promise<RouterTypes.SignExecuteMethodResult<"getReserveInAndReserveOut">>;
        swapExactTokenForToken: (params: RouterTypes.SignExecuteMethodParams<"swapExactTokenForToken">) => Promise<RouterTypes.SignExecuteMethodResult<"swapExactTokenForToken">>;
        swapTokenForExactToken: (params: RouterTypes.SignExecuteMethodParams<"swapTokenForExactToken">) => Promise<RouterTypes.SignExecuteMethodResult<"swapTokenForExactToken">>;
        swap: (params: RouterTypes.SignExecuteMethodParams<"swap">) => Promise<RouterTypes.SignExecuteMethodResult<"swap">>;
    };
    multicall<Calls extends RouterTypes.MultiCallParams>(calls: Calls): Promise<RouterTypes.MultiCallResults<Calls>>;
    multicall<Callss extends RouterTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<RouterTypes.MulticallReturnType<Callss>>;
}

declare namespace TestTokenTypes {
    type Fields = {
        symbol: HexString;
        name: HexString;
        decimals: bigint;
        totalSupply: bigint;
    };
    type State = ContractState<Fields>;
    interface CallMethodTable {
        getSymbol: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getName: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<HexString>;
        };
        getDecimals: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        getTotalSupply: {
            params: Omit<CallContractParams<{}>, "args">;
            result: CallContractResult<bigint>;
        };
        getToken: {
            params: CallContractParams<{
                sender: Address;
                amount: bigint;
            }>;
            result: CallContractResult<null>;
        };
    }
    type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
    type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
    type MultiCallParams = Partial<{
        [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
    }>;
    type MultiCallResults<T extends MultiCallParams> = {
        [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable ? CallMethodTable[MaybeName]["result"] : undefined;
    };
    type MulticallReturnType<Callss extends MultiCallParams[]> = {
        [index in keyof Callss]: MultiCallResults<Callss[index]>;
    };
    interface SignExecuteMethodTable {
        getSymbol: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getName: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getDecimals: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getTotalSupply: {
            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
            result: SignExecuteScriptTxResult;
        };
        getToken: {
            params: SignExecuteContractMethodParams<{
                sender: Address;
                amount: bigint;
            }>;
            result: SignExecuteScriptTxResult;
        };
    }
    type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
    type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
}
declare class Factory extends ContractFactory<TestTokenInstance, TestTokenTypes.Fields> {
    encodeFields(fields: TestTokenTypes.Fields): {
        encodedImmFields: Uint8Array;
        encodedMutFields: Uint8Array;
    };
    at(address: string): TestTokenInstance;
    tests: {
        getSymbol: (params: Omit<TestContractParamsWithoutMaps<TestTokenTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<HexString>>;
        getName: (params: Omit<TestContractParamsWithoutMaps<TestTokenTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<HexString>>;
        getDecimals: (params: Omit<TestContractParamsWithoutMaps<TestTokenTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        getTotalSupply: (params: Omit<TestContractParamsWithoutMaps<TestTokenTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<bigint>>;
        getToken: (params: TestContractParamsWithoutMaps<TestTokenTypes.Fields, {
            sender: Address;
            amount: bigint;
        }>) => Promise<TestContractResultWithoutMaps<null>>;
    };
    stateForTest(initFields: TestTokenTypes.Fields, asset?: Asset, address?: string): ContractState<TestTokenTypes.Fields> | _alephium_web3.ContractStateWithMaps<TestTokenTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
}
declare const TestToken: Factory;
declare class TestTokenInstance extends ContractInstance {
    constructor(address: Address);
    fetchState(): Promise<TestTokenTypes.State>;
    view: {
        getSymbol: (params?: TestTokenTypes.CallMethodParams<"getSymbol">) => Promise<TestTokenTypes.CallMethodResult<"getSymbol">>;
        getName: (params?: TestTokenTypes.CallMethodParams<"getName">) => Promise<TestTokenTypes.CallMethodResult<"getName">>;
        getDecimals: (params?: TestTokenTypes.CallMethodParams<"getDecimals">) => Promise<TestTokenTypes.CallMethodResult<"getDecimals">>;
        getTotalSupply: (params?: TestTokenTypes.CallMethodParams<"getTotalSupply">) => Promise<TestTokenTypes.CallMethodResult<"getTotalSupply">>;
        getToken: (params: TestTokenTypes.CallMethodParams<"getToken">) => Promise<TestTokenTypes.CallMethodResult<"getToken">>;
    };
    transact: {
        getSymbol: (params: TestTokenTypes.SignExecuteMethodParams<"getSymbol">) => Promise<TestTokenTypes.SignExecuteMethodResult<"getSymbol">>;
        getName: (params: TestTokenTypes.SignExecuteMethodParams<"getName">) => Promise<TestTokenTypes.SignExecuteMethodResult<"getName">>;
        getDecimals: (params: TestTokenTypes.SignExecuteMethodParams<"getDecimals">) => Promise<TestTokenTypes.SignExecuteMethodResult<"getDecimals">>;
        getTotalSupply: (params: TestTokenTypes.SignExecuteMethodParams<"getTotalSupply">) => Promise<TestTokenTypes.SignExecuteMethodResult<"getTotalSupply">>;
        getToken: (params: TestTokenTypes.SignExecuteMethodParams<"getToken">) => Promise<TestTokenTypes.SignExecuteMethodResult<"getToken">>;
    };
    multicall<Calls extends TestTokenTypes.MultiCallParams>(calls: Calls): Promise<TestTokenTypes.MultiCallResults<Calls>>;
    multicall<Callss extends TestTokenTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<TestTokenTypes.MulticallReturnType<Callss>>;
}

declare function getAllContracts(): ContractFactory<any>[];
declare function registerContract(factory: ContractFactory<any>): void;
declare function getContractByCodeHash(codeHash: string): Contract;

declare const AddLiquidity: ExecutableScript<{
    sender: Address;
    router: HexString;
    pair: HexString;
    amount0Desired: bigint;
    amount1Desired: bigint;
    amount0Min: bigint;
    amount1Min: bigint;
    deadline: bigint;
}, null>;
declare const Burn: ExecutableScript<{
    tokenPair: HexString;
    sender: Address;
    liquidity: bigint;
}, null>;
declare const CollectFee: ExecutableScript<{
    feeCollector: HexString;
}, null>;
declare const CreatePair: ExecutableScript<{
    payer: Address;
    factory: HexString;
    alphAmount: bigint;
    tokenAId: HexString;
    tokenBId: HexString;
}, null>;
declare const CreatePairAndAddLiquidity: ExecutableScript<{
    payer: Address;
    factory: HexString;
    alphAmount: bigint;
    token0Id: HexString;
    token1Id: HexString;
    amount0: bigint;
    amount1: bigint;
}, null>;
declare const EnableFeeCollector: ExecutableScript<{
    tokenPairFactory: HexString;
    tokenPair: HexString;
}, null>;
declare const GetToken: ExecutableScript<{
    token: HexString;
    sender: Address;
    amount: bigint;
}, null>;
declare const Mint: ExecutableScript<{
    tokenPair: HexString;
    sender: Address;
    amount0: bigint;
    amount1: bigint;
}, null>;
declare const RemoveLiquidity: ExecutableScript<{
    sender: Address;
    router: HexString;
    pairId: HexString;
    liquidity: bigint;
    amount0Min: bigint;
    amount1Min: bigint;
    deadline: bigint;
}, null>;
declare const SetFeeCollectorFactory: ExecutableScript<{
    tokenPairFactory: HexString;
    feeCollectorFactory: HexString;
}, null>;
declare const Swap: ExecutableScript<{
    dexAccount: HexString;
    tokenPair: HexString;
    sender: Address;
    to: Address;
    amount0In: bigint;
    amount1In: bigint;
    amount0Out: bigint;
    amount1Out: bigint;
}, null>;
declare const SwapMaxIn: ExecutableScript<{
    dexAccount: HexString;
    sender: Address;
    router: HexString;
    pair: HexString;
    tokenInId: HexString;
    amountInMax: bigint;
    amountOut: bigint;
    deadline: bigint;
}, null>;
declare const SwapMinOut: ExecutableScript<{
    dexAccount: HexString;
    sender: Address;
    router: HexString;
    pair: HexString;
    tokenInId: HexString;
    amountIn: bigint;
    amountOutMin: bigint;
    deadline: bigint;
}, null>;

declare const scripts_AddLiquidity: typeof AddLiquidity;
declare const scripts_Burn: typeof Burn;
declare const scripts_CollectFee: typeof CollectFee;
declare const scripts_CreatePair: typeof CreatePair;
declare const scripts_CreatePairAndAddLiquidity: typeof CreatePairAndAddLiquidity;
declare const scripts_EnableFeeCollector: typeof EnableFeeCollector;
declare const scripts_GetToken: typeof GetToken;
declare const scripts_Mint: typeof Mint;
declare const scripts_RemoveLiquidity: typeof RemoveLiquidity;
declare const scripts_SetFeeCollectorFactory: typeof SetFeeCollectorFactory;
declare const scripts_Swap: typeof Swap;
declare const scripts_SwapMaxIn: typeof SwapMaxIn;
declare const scripts_SwapMinOut: typeof SwapMinOut;
declare namespace scripts {
  export { scripts_AddLiquidity as AddLiquidity, scripts_Burn as Burn, scripts_CollectFee as CollectFee, scripts_CreatePair as CreatePair, scripts_CreatePairAndAddLiquidity as CreatePairAndAddLiquidity, scripts_EnableFeeCollector as EnableFeeCollector, scripts_GetToken as GetToken, scripts_Mint as Mint, scripts_RemoveLiquidity as RemoveLiquidity, scripts_SetFeeCollectorFactory as SetFeeCollectorFactory, scripts_Swap as Swap, scripts_SwapMaxIn as SwapMaxIn, scripts_SwapMinOut as SwapMinOut };
}

declare const index_AddLiquidity: typeof AddLiquidity;
declare const index_Burn: typeof Burn;
declare const index_CollectFee: typeof CollectFee;
declare const index_CreatePair: typeof CreatePair;
declare const index_CreatePairAndAddLiquidity: typeof CreatePairAndAddLiquidity;
declare const index_DexAccount: typeof DexAccount;
type index_DexAccountInstance = DexAccountInstance;
declare const index_DexAccountInstance: typeof DexAccountInstance;
declare const index_DexAccountTypes: typeof DexAccountTypes;
declare const index_EnableFeeCollector: typeof EnableFeeCollector;
declare const index_ExampleOracleSimple: typeof ExampleOracleSimple;
type index_ExampleOracleSimpleInstance = ExampleOracleSimpleInstance;
declare const index_ExampleOracleSimpleInstance: typeof ExampleOracleSimpleInstance;
declare const index_ExampleOracleSimpleTypes: typeof ExampleOracleSimpleTypes;
declare const index_FeeCollectorFactoryImpl: typeof FeeCollectorFactoryImpl;
type index_FeeCollectorFactoryImplInstance = FeeCollectorFactoryImplInstance;
declare const index_FeeCollectorFactoryImplInstance: typeof FeeCollectorFactoryImplInstance;
declare const index_FeeCollectorFactoryImplTypes: typeof FeeCollectorFactoryImplTypes;
declare const index_FeeCollectorPerTokenPairImpl: typeof FeeCollectorPerTokenPairImpl;
type index_FeeCollectorPerTokenPairImplInstance = FeeCollectorPerTokenPairImplInstance;
declare const index_FeeCollectorPerTokenPairImplInstance: typeof FeeCollectorPerTokenPairImplInstance;
declare const index_FeeCollectorPerTokenPairImplTypes: typeof FeeCollectorPerTokenPairImplTypes;
declare const index_FullMathTest: typeof FullMathTest;
type index_FullMathTestInstance = FullMathTestInstance;
declare const index_FullMathTestInstance: typeof FullMathTestInstance;
declare const index_FullMathTestTypes: typeof FullMathTestTypes;
declare const index_GetToken: typeof GetToken;
declare const index_MathTest: typeof MathTest;
type index_MathTestInstance = MathTestInstance;
declare const index_MathTestInstance: typeof MathTestInstance;
declare const index_MathTestTypes: typeof MathTestTypes;
declare const index_Mint: typeof Mint;
declare const index_RemoveLiquidity: typeof RemoveLiquidity;
declare const index_Router: typeof Router;
type index_RouterInstance = RouterInstance;
declare const index_RouterInstance: typeof RouterInstance;
declare const index_RouterTypes: typeof RouterTypes;
declare const index_SetFeeCollectorFactory: typeof SetFeeCollectorFactory;
declare const index_Swap: typeof Swap;
declare const index_SwapMaxIn: typeof SwapMaxIn;
declare const index_SwapMinOut: typeof SwapMinOut;
declare const index_TestToken: typeof TestToken;
type index_TestTokenInstance = TestTokenInstance;
declare const index_TestTokenInstance: typeof TestTokenInstance;
declare const index_TestTokenTypes: typeof TestTokenTypes;
declare const index_TokenPair: typeof TokenPair;
declare const index_TokenPairFactory: typeof TokenPairFactory;
type index_TokenPairFactoryInstance = TokenPairFactoryInstance;
declare const index_TokenPairFactoryInstance: typeof TokenPairFactoryInstance;
declare const index_TokenPairFactoryTypes: typeof TokenPairFactoryTypes;
type index_TokenPairInstance = TokenPairInstance;
declare const index_TokenPairInstance: typeof TokenPairInstance;
declare const index_TokenPairTypes: typeof TokenPairTypes;
declare const index_getAllContracts: typeof getAllContracts;
declare const index_getContractByCodeHash: typeof getContractByCodeHash;
declare const index_registerContract: typeof registerContract;
declare namespace index {
  export { index_AddLiquidity as AddLiquidity, index_Burn as Burn, index_CollectFee as CollectFee, index_CreatePair as CreatePair, index_CreatePairAndAddLiquidity as CreatePairAndAddLiquidity, index_DexAccount as DexAccount, index_DexAccountInstance as DexAccountInstance, index_DexAccountTypes as DexAccountTypes, index_EnableFeeCollector as EnableFeeCollector, index_ExampleOracleSimple as ExampleOracleSimple, index_ExampleOracleSimpleInstance as ExampleOracleSimpleInstance, index_ExampleOracleSimpleTypes as ExampleOracleSimpleTypes, index_FeeCollectorFactoryImpl as FeeCollectorFactoryImpl, index_FeeCollectorFactoryImplInstance as FeeCollectorFactoryImplInstance, index_FeeCollectorFactoryImplTypes as FeeCollectorFactoryImplTypes, index_FeeCollectorPerTokenPairImpl as FeeCollectorPerTokenPairImpl, index_FeeCollectorPerTokenPairImplInstance as FeeCollectorPerTokenPairImplInstance, index_FeeCollectorPerTokenPairImplTypes as FeeCollectorPerTokenPairImplTypes, index_FullMathTest as FullMathTest, index_FullMathTestInstance as FullMathTestInstance, index_FullMathTestTypes as FullMathTestTypes, index_GetToken as GetToken, index_MathTest as MathTest, index_MathTestInstance as MathTestInstance, index_MathTestTypes as MathTestTypes, index_Mint as Mint, index_RemoveLiquidity as RemoveLiquidity, index_Router as Router, index_RouterInstance as RouterInstance, index_RouterTypes as RouterTypes, index_SetFeeCollectorFactory as SetFeeCollectorFactory, index_Swap as Swap, index_SwapMaxIn as SwapMaxIn, index_SwapMinOut as SwapMinOut, index_TestToken as TestToken, index_TestTokenInstance as TestTokenInstance, index_TestTokenTypes as TestTokenTypes, index_TokenPair as TokenPair, index_TokenPairFactory as TokenPairFactory, index_TokenPairFactoryInstance as TokenPairFactoryInstance, index_TokenPairFactoryTypes as TokenPairFactoryTypes, index_TokenPairInstance as TokenPairInstance, index_TokenPairTypes as TokenPairTypes, index_getAllContracts as getAllContracts, index_getContractByCodeHash as getContractByCodeHash, index_registerContract as registerContract };
}

type Deployments$2 = {
    deployerAddress: string;
    contracts: {
        TokenPair: DeployContractExecutionResult<TokenPairInstance>;
        TokenPairFactory: DeployContractExecutionResult<TokenPairFactoryInstance>;
        Router: DeployContractExecutionResult<RouterInstance>;
        FeeCollectorPerTokenPairImpl: DeployContractExecutionResult<FeeCollectorPerTokenPairImplInstance>;
        FeeCollectorFactoryImpl: DeployContractExecutionResult<FeeCollectorFactoryImplInstance>;
    };
};
declare function loadDeployments$2(networkId: NetworkId, deployerAddress?: string): Deployments$2;

type Deployments$1 = {
    deployerAddress: string;
    contracts: {
        Pool: DeployContractExecutionResult<PoolInstance>;
        Position: DeployContractExecutionResult<PositionInstance>;
        Tick: DeployContractExecutionResult<TickInstance>;
        BitmapWord: DeployContractExecutionResult<BitmapWordInstance>;
        PoolConfig: DeployContractExecutionResult<PoolConfigInstance>;
        DexAccount: DeployContractExecutionResult<DexAccountInstance$1>;
        PoolFactory: DeployContractExecutionResult<PoolFactoryInstance>;
        PositionManager: DeployContractExecutionResult<PositionManagerInstance>;
    };
    scripts: {
        CreateConfig_CreateConfig0: RunScriptResult;
        CreateConfig_CreateConfig1: RunScriptResult;
        CreateConfig_CreateConfig2: RunScriptResult;
        CreateConfig_CreateConfig3: RunScriptResult;
        CreateConfig_CreateConfig4: RunScriptResult;
        CreateConfig_CreateConfig5: RunScriptResult;
        CreateConfig_CreateConfig6: RunScriptResult;
        CreateConfig_CreateConfig7: RunScriptResult;
        CreateConfig_CreateConfig8: RunScriptResult;
        CreateConfig_CreateConfig9: RunScriptResult;
    };
};
declare function loadDeployments$1(networkId: NetworkId, deployerAddress?: string): Deployments$1;

type Deployments = {
    deployerAddress: string;
    contracts: {
        AlphUnstakeVault: DeployContractExecutionResult<AlphUnstakeVaultInstance>;
        XAlphToken: DeployContractExecutionResult<XAlphTokenInstance>;
        GovernanceDemo: DeployContractExecutionResult<GovernanceDemoInstance>;
        RewardSharingVault: DeployContractExecutionResult<RewardSharingVaultInstance>;
        XAlphStakeVault: DeployContractExecutionResult<XAlphStakeVaultInstance>;
    };
};
declare function loadDeployments(networkId: NetworkId, deployerAddress?: string): Deployments;

export { type AddLiquidity$1 as AddLiquidity, type AddLiquidityDetails, type AddLiquidityParams, BPS, type ClaimableAmounts, type ClmmConfig, index$2 as ClmmContracts, ClmmLiquidityUtils, ClmmModule, type ClmmPoolConfig, type ClmmPoolContractState, PoolFactoryTypes as ClmmPoolFactoryTypes, PoolTypes as ClmmPoolTypes, type ClmmPositionInfo, PositionManagerTypes as ClmmPositionManagerTypes, scripts$1 as ClmmScripts, type ClmmSwapParams, type CollectProtocolFees, type CollectTokens, type ComputeLiquidityParams, type ComputeSwapParams, type CpmmConfig, index as CpmmContracts, CpmmModule, type CpmmPoolContractState, scripts as CpmmScripts, TokenPairFactoryTypes as CpmmTokenPairFactoryTypes, TokenPairTypes as CpmmTokenPairTypes, type CreatePoolParams, DEVNET, type ExtendRewards, type GetPositionAmountsFromPriceProps, type GetPositionAmountsFromPriceReturn, GovernanceDemoTypes, InsufficientBalanceError, InsufficientLiquidityError, type LiquidityDistribution, type LiquidityForPrice, LogLevel, Logger, MAX_PIPS, MAX_PRICE_IMPACT, MAX_TICK, MINIMUM_LIQUIDITY, MIN_TICK, MathUtil, type Network, type NetworkOverrides, type NumericLike, NumericUtils, PoolNotFoundError, PoolUtils, type PositionPath, PriceImpactTooHighError, type RemoveLiquidity$1 as RemoveLiquidity, type RemoveLiquidityDetails, type RemoveLiquidityParams, RewardSharingVaultTypes, type Rounding, type SetRewardParams, type SimulateSwap, type StakeVaultUserInfo, type StakingConfig, index$1 as StakingContracts, StakingModule, type StakingSettings, type SwapDetails, type SwapParams$1 as SwapParams, TickUtils, TokenListFetchError, TokenModule, U256_MAX, UNLIMITED_AMOUNT, XAlphStakeVaultTypes, XAlphTokenTypes, Zeta, type ZetaLoadParams, ZetaSDKError, createLogger, decodeContractIdList, decodeU256List, defaultNetworks, getStakingSettings, loadDeployments$1 as loadClmmDeployments, loadDeployments$2 as loadCpmmDeployments, loadDeployments as loadStakingDeployments, setLoggerLevel, sortTokens, stakingSettingsByNetwork };