@merkl/contracts 1.2.3 → 1.2.5

package/dist/src/AerodromeCLFactory.d.ts

@@ -0,0 +1,417 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "./common";
+export interface AerodromeCLFactoryInterface extends utils.Interface {
+    functions: {
+        "allPools(uint256)": FunctionFragment;
+        "allPoolsLength()": FunctionFragment;
+        "createPool(address,address,int24,uint160)": FunctionFragment;
+        "defaultUnstakedFee()": FunctionFragment;
+        "enableTickSpacing(int24,uint24)": FunctionFragment;
+        "factoryRegistry()": FunctionFragment;
+        "getPool(address,address,int24)": FunctionFragment;
+        "getSwapFee(address)": FunctionFragment;
+        "getUnstakedFee(address)": FunctionFragment;
+        "isPool(address)": FunctionFragment;
+        "owner()": FunctionFragment;
+        "poolImplementation()": FunctionFragment;
+        "setDefaultUnstakedFee(uint24)": FunctionFragment;
+        "setOwner(address)": FunctionFragment;
+        "setSwapFeeManager(address)": FunctionFragment;
+        "setSwapFeeModule(address)": FunctionFragment;
+        "setUnstakedFeeManager(address)": FunctionFragment;
+        "setUnstakedFeeModule(address)": FunctionFragment;
+        "swapFeeManager()": FunctionFragment;
+        "swapFeeModule()": FunctionFragment;
+        "tickSpacingToFee(int24)": FunctionFragment;
+        "tickSpacings()": FunctionFragment;
+        "unstakedFeeManager()": FunctionFragment;
+        "unstakedFeeModule()": FunctionFragment;
+        "voter()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "allPools" | "allPoolsLength" | "createPool" | "defaultUnstakedFee" | "enableTickSpacing" | "factoryRegistry" | "getPool" | "getSwapFee" | "getUnstakedFee" | "isPool" | "owner" | "poolImplementation" | "setDefaultUnstakedFee" | "setOwner" | "setSwapFeeManager" | "setSwapFeeModule" | "setUnstakedFeeManager" | "setUnstakedFeeModule" | "swapFeeManager" | "swapFeeModule" | "tickSpacingToFee" | "tickSpacings" | "unstakedFeeManager" | "unstakedFeeModule" | "voter"): FunctionFragment;
+    encodeFunctionData(functionFragment: "allPools", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "allPoolsLength", values?: undefined): string;
+    encodeFunctionData(functionFragment: "createPool", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "defaultUnstakedFee", values?: undefined): string;
+    encodeFunctionData(functionFragment: "enableTickSpacing", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "factoryRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getPool", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "getSwapFee", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "getUnstakedFee", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "isPool", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "poolImplementation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setDefaultUnstakedFee", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "setOwner", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setSwapFeeManager", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setSwapFeeModule", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setUnstakedFeeManager", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setUnstakedFeeModule", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "swapFeeManager", values?: undefined): string;
+    encodeFunctionData(functionFragment: "swapFeeModule", values?: undefined): string;
+    encodeFunctionData(functionFragment: "tickSpacingToFee", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "tickSpacings", values?: undefined): string;
+    encodeFunctionData(functionFragment: "unstakedFeeManager", values?: undefined): string;
+    encodeFunctionData(functionFragment: "unstakedFeeModule", values?: undefined): string;
+    encodeFunctionData(functionFragment: "voter", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "allPools", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allPoolsLength", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createPool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "defaultUnstakedFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "enableTickSpacing", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "factoryRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getSwapFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getUnstakedFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isPool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "poolImplementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setDefaultUnstakedFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setSwapFeeManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setSwapFeeModule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setUnstakedFeeManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setUnstakedFeeModule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapFeeManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapFeeModule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tickSpacingToFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tickSpacings", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unstakedFeeManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unstakedFeeModule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "voter", data: BytesLike): Result;
+    events: {
+        "DefaultUnstakedFeeChanged(uint24,uint24)": EventFragment;
+        "OwnerChanged(address,address)": EventFragment;
+        "PoolCreated(address,address,int24,address)": EventFragment;
+        "SwapFeeManagerChanged(address,address)": EventFragment;
+        "SwapFeeModuleChanged(address,address)": EventFragment;
+        "TickSpacingEnabled(int24,uint24)": EventFragment;
+        "UnstakedFeeManagerChanged(address,address)": EventFragment;
+        "UnstakedFeeModuleChanged(address,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "DefaultUnstakedFeeChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnerChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PoolCreated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "SwapFeeManagerChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "SwapFeeModuleChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TickSpacingEnabled"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "UnstakedFeeManagerChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "UnstakedFeeModuleChanged"): EventFragment;
+}
+export interface DefaultUnstakedFeeChangedEventObject {
+    oldUnstakedFee: number;
+    newUnstakedFee: number;
+}
+export type DefaultUnstakedFeeChangedEvent = TypedEvent<[
+    number,
+    number
+], DefaultUnstakedFeeChangedEventObject>;
+export type DefaultUnstakedFeeChangedEventFilter = TypedEventFilter<DefaultUnstakedFeeChangedEvent>;
+export interface OwnerChangedEventObject {
+    oldOwner: string;
+    newOwner: string;
+}
+export type OwnerChangedEvent = TypedEvent<[
+    string,
+    string
+], OwnerChangedEventObject>;
+export type OwnerChangedEventFilter = TypedEventFilter<OwnerChangedEvent>;
+export interface PoolCreatedEventObject {
+    token0: string;
+    token1: string;
+    tickSpacing: number;
+    pool: string;
+}
+export type PoolCreatedEvent = TypedEvent<[
+    string,
+    string,
+    number,
+    string
+], PoolCreatedEventObject>;
+export type PoolCreatedEventFilter = TypedEventFilter<PoolCreatedEvent>;
+export interface SwapFeeManagerChangedEventObject {
+    oldFeeManager: string;
+    newFeeManager: string;
+}
+export type SwapFeeManagerChangedEvent = TypedEvent<[
+    string,
+    string
+], SwapFeeManagerChangedEventObject>;
+export type SwapFeeManagerChangedEventFilter = TypedEventFilter<SwapFeeManagerChangedEvent>;
+export interface SwapFeeModuleChangedEventObject {
+    oldFeeModule: string;
+    newFeeModule: string;
+}
+export type SwapFeeModuleChangedEvent = TypedEvent<[
+    string,
+    string
+], SwapFeeModuleChangedEventObject>;
+export type SwapFeeModuleChangedEventFilter = TypedEventFilter<SwapFeeModuleChangedEvent>;
+export interface TickSpacingEnabledEventObject {
+    tickSpacing: number;
+    fee: number;
+}
+export type TickSpacingEnabledEvent = TypedEvent<[
+    number,
+    number
+], TickSpacingEnabledEventObject>;
+export type TickSpacingEnabledEventFilter = TypedEventFilter<TickSpacingEnabledEvent>;
+export interface UnstakedFeeManagerChangedEventObject {
+    oldFeeManager: string;
+    newFeeManager: string;
+}
+export type UnstakedFeeManagerChangedEvent = TypedEvent<[
+    string,
+    string
+], UnstakedFeeManagerChangedEventObject>;
+export type UnstakedFeeManagerChangedEventFilter = TypedEventFilter<UnstakedFeeManagerChangedEvent>;
+export interface UnstakedFeeModuleChangedEventObject {
+    oldFeeModule: string;
+    newFeeModule: string;
+}
+export type UnstakedFeeModuleChangedEvent = TypedEvent<[
+    string,
+    string
+], UnstakedFeeModuleChangedEventObject>;
+export type UnstakedFeeModuleChangedEventFilter = TypedEventFilter<UnstakedFeeModuleChangedEvent>;
+export interface AerodromeCLFactory extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: AerodromeCLFactoryInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        allPools(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        allPoolsLength(overrides?: CallOverrides): Promise<[BigNumber]>;
+        createPool(tokenA: PromiseOrValue<string>, tokenB: PromiseOrValue<string>, tickSpacing: PromiseOrValue<BigNumberish>, sqrtPriceX96: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        defaultUnstakedFee(overrides?: CallOverrides): Promise<[number]>;
+        enableTickSpacing(tickSpacing: PromiseOrValue<BigNumberish>, fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        factoryRegistry(overrides?: CallOverrides): Promise<[string]>;
+        getPool(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, arg2: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        getSwapFee(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[number]>;
+        getUnstakedFee(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[number]>;
+        isPool(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        poolImplementation(overrides?: CallOverrides): Promise<[string]>;
+        setDefaultUnstakedFee(_defaultUnstakedFee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setOwner(_owner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setSwapFeeManager(_swapFeeManager: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setSwapFeeModule(_swapFeeModule: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setUnstakedFeeManager(_unstakedFeeManager: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setUnstakedFeeModule(_unstakedFeeModule: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        swapFeeManager(overrides?: CallOverrides): Promise<[string]>;
+        swapFeeModule(overrides?: CallOverrides): Promise<[string]>;
+        tickSpacingToFee(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[number]>;
+        tickSpacings(overrides?: CallOverrides): Promise<[number[]]>;
+        unstakedFeeManager(overrides?: CallOverrides): Promise<[string]>;
+        unstakedFeeModule(overrides?: CallOverrides): Promise<[string]>;
+        voter(overrides?: CallOverrides): Promise<[string]>;
+    };
+    allPools(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    allPoolsLength(overrides?: CallOverrides): Promise<BigNumber>;
+    createPool(tokenA: PromiseOrValue<string>, tokenB: PromiseOrValue<string>, tickSpacing: PromiseOrValue<BigNumberish>, sqrtPriceX96: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    defaultUnstakedFee(overrides?: CallOverrides): Promise<number>;
+    enableTickSpacing(tickSpacing: PromiseOrValue<BigNumberish>, fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    factoryRegistry(overrides?: CallOverrides): Promise<string>;
+    getPool(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, arg2: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    getSwapFee(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
+    getUnstakedFee(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
+    isPool(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    poolImplementation(overrides?: CallOverrides): Promise<string>;
+    setDefaultUnstakedFee(_defaultUnstakedFee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setOwner(_owner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setSwapFeeManager(_swapFeeManager: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setSwapFeeModule(_swapFeeModule: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setUnstakedFeeManager(_unstakedFeeManager: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setUnstakedFeeModule(_unstakedFeeModule: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    swapFeeManager(overrides?: CallOverrides): Promise<string>;
+    swapFeeModule(overrides?: CallOverrides): Promise<string>;
+    tickSpacingToFee(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<number>;
+    tickSpacings(overrides?: CallOverrides): Promise<number[]>;
+    unstakedFeeManager(overrides?: CallOverrides): Promise<string>;
+    unstakedFeeModule(overrides?: CallOverrides): Promise<string>;
+    voter(overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        allPools(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        allPoolsLength(overrides?: CallOverrides): Promise<BigNumber>;
+        createPool(tokenA: PromiseOrValue<string>, tokenB: PromiseOrValue<string>, tickSpacing: PromiseOrValue<BigNumberish>, sqrtPriceX96: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        defaultUnstakedFee(overrides?: CallOverrides): Promise<number>;
+        enableTickSpacing(tickSpacing: PromiseOrValue<BigNumberish>, fee: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        factoryRegistry(overrides?: CallOverrides): Promise<string>;
+        getPool(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, arg2: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        getSwapFee(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
+        getUnstakedFee(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
+        isPool(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        poolImplementation(overrides?: CallOverrides): Promise<string>;
+        setDefaultUnstakedFee(_defaultUnstakedFee: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        setOwner(_owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setSwapFeeManager(_swapFeeManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setSwapFeeModule(_swapFeeModule: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setUnstakedFeeManager(_unstakedFeeManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setUnstakedFeeModule(_unstakedFeeModule: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        swapFeeManager(overrides?: CallOverrides): Promise<string>;
+        swapFeeModule(overrides?: CallOverrides): Promise<string>;
+        tickSpacingToFee(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<number>;
+        tickSpacings(overrides?: CallOverrides): Promise<number[]>;
+        unstakedFeeManager(overrides?: CallOverrides): Promise<string>;
+        unstakedFeeModule(overrides?: CallOverrides): Promise<string>;
+        voter(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {
+        "DefaultUnstakedFeeChanged(uint24,uint24)"(oldUnstakedFee?: PromiseOrValue<BigNumberish> | null, newUnstakedFee?: PromiseOrValue<BigNumberish> | null): DefaultUnstakedFeeChangedEventFilter;
+        DefaultUnstakedFeeChanged(oldUnstakedFee?: PromiseOrValue<BigNumberish> | null, newUnstakedFee?: PromiseOrValue<BigNumberish> | null): DefaultUnstakedFeeChangedEventFilter;
+        "OwnerChanged(address,address)"(oldOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnerChangedEventFilter;
+        OwnerChanged(oldOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnerChangedEventFilter;
+        "PoolCreated(address,address,int24,address)"(token0?: PromiseOrValue<string> | null, token1?: PromiseOrValue<string> | null, tickSpacing?: PromiseOrValue<BigNumberish> | null, pool?: null): PoolCreatedEventFilter;
+        PoolCreated(token0?: PromiseOrValue<string> | null, token1?: PromiseOrValue<string> | null, tickSpacing?: PromiseOrValue<BigNumberish> | null, pool?: null): PoolCreatedEventFilter;
+        "SwapFeeManagerChanged(address,address)"(oldFeeManager?: PromiseOrValue<string> | null, newFeeManager?: PromiseOrValue<string> | null): SwapFeeManagerChangedEventFilter;
+        SwapFeeManagerChanged(oldFeeManager?: PromiseOrValue<string> | null, newFeeManager?: PromiseOrValue<string> | null): SwapFeeManagerChangedEventFilter;
+        "SwapFeeModuleChanged(address,address)"(oldFeeModule?: PromiseOrValue<string> | null, newFeeModule?: PromiseOrValue<string> | null): SwapFeeModuleChangedEventFilter;
+        SwapFeeModuleChanged(oldFeeModule?: PromiseOrValue<string> | null, newFeeModule?: PromiseOrValue<string> | null): SwapFeeModuleChangedEventFilter;
+        "TickSpacingEnabled(int24,uint24)"(tickSpacing?: PromiseOrValue<BigNumberish> | null, fee?: PromiseOrValue<BigNumberish> | null): TickSpacingEnabledEventFilter;
+        TickSpacingEnabled(tickSpacing?: PromiseOrValue<BigNumberish> | null, fee?: PromiseOrValue<BigNumberish> | null): TickSpacingEnabledEventFilter;
+        "UnstakedFeeManagerChanged(address,address)"(oldFeeManager?: PromiseOrValue<string> | null, newFeeManager?: PromiseOrValue<string> | null): UnstakedFeeManagerChangedEventFilter;
+        UnstakedFeeManagerChanged(oldFeeManager?: PromiseOrValue<string> | null, newFeeManager?: PromiseOrValue<string> | null): UnstakedFeeManagerChangedEventFilter;
+        "UnstakedFeeModuleChanged(address,address)"(oldFeeModule?: PromiseOrValue<string> | null, newFeeModule?: PromiseOrValue<string> | null): UnstakedFeeModuleChangedEventFilter;
+        UnstakedFeeModuleChanged(oldFeeModule?: PromiseOrValue<string> | null, newFeeModule?: PromiseOrValue<string> | null): UnstakedFeeModuleChangedEventFilter;
+    };
+    estimateGas: {
+        allPools(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        allPoolsLength(overrides?: CallOverrides): Promise<BigNumber>;
+        createPool(tokenA: PromiseOrValue<string>, tokenB: PromiseOrValue<string>, tickSpacing: PromiseOrValue<BigNumberish>, sqrtPriceX96: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        defaultUnstakedFee(overrides?: CallOverrides): Promise<BigNumber>;
+        enableTickSpacing(tickSpacing: PromiseOrValue<BigNumberish>, fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        factoryRegistry(overrides?: CallOverrides): Promise<BigNumber>;
+        getPool(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, arg2: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        getSwapFee(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        getUnstakedFee(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        isPool(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        poolImplementation(overrides?: CallOverrides): Promise<BigNumber>;
+        setDefaultUnstakedFee(_defaultUnstakedFee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setOwner(_owner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setSwapFeeManager(_swapFeeManager: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setSwapFeeModule(_swapFeeModule: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setUnstakedFeeManager(_unstakedFeeManager: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setUnstakedFeeModule(_unstakedFeeModule: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        swapFeeManager(overrides?: CallOverrides): Promise<BigNumber>;
+        swapFeeModule(overrides?: CallOverrides): Promise<BigNumber>;
+        tickSpacingToFee(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        tickSpacings(overrides?: CallOverrides): Promise<BigNumber>;
+        unstakedFeeManager(overrides?: CallOverrides): Promise<BigNumber>;
+        unstakedFeeModule(overrides?: CallOverrides): Promise<BigNumber>;
+        voter(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        allPools(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        allPoolsLength(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        createPool(tokenA: PromiseOrValue<string>, tokenB: PromiseOrValue<string>, tickSpacing: PromiseOrValue<BigNumberish>, sqrtPriceX96: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        defaultUnstakedFee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        enableTickSpacing(tickSpacing: PromiseOrValue<BigNumberish>, fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        factoryRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getPool(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, arg2: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getSwapFee(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getUnstakedFee(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isPool(pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        poolImplementation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setDefaultUnstakedFee(_defaultUnstakedFee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setOwner(_owner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setSwapFeeManager(_swapFeeManager: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setSwapFeeModule(_swapFeeModule: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setUnstakedFeeManager(_unstakedFeeManager: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setUnstakedFeeModule(_unstakedFeeModule: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        swapFeeManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        swapFeeModule(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        tickSpacingToFee(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        tickSpacings(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        unstakedFeeManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        unstakedFeeModule(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        voter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/src/AerodromeCLFactory.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AerodromeCLFactory.js.map

package/dist/src/AerodromeCLFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AerodromeCLFactory.js","sourceRoot":"","sources":["../../src/AerodromeCLFactory.ts"],"names":[],"mappings":""}