import { Address, WalletClient, Hex, Hash, Account, PublicClient, TransactionReceipt } from 'viem';
import { mainnet, sepolia, arbitrum, base, baseSepolia, ink, unichain } from 'viem/chains';

declare const CHAIN_IDS: {
    readonly MAINNET: 1;
    readonly ETH_SEPOLIA: 11155111;
    readonly ARBITRUM: 42161;
    readonly BASE: 8453;
    readonly BASE_SEPOLIA: 84532;
    readonly INK: 57073;
    readonly ROBINHOOD: 4663;
    readonly UNICHAIN: 130;
    readonly UNICHAIN_SEPOLIA: 1301;
    readonly MONAD_TESTNET: 10143;
    readonly MONAD_MAINNET: 143;
};
type SupportedChainId = (typeof CHAIN_IDS)[keyof typeof CHAIN_IDS];
type SupportedChainKey = keyof typeof CHAIN_IDS;
interface ChainAddresses {
    airlock: Address;
    tokenFactory: Address;
    derc20V2Factory?: Address;
    derc20V2Implementation?: Address;
    dopplerERC20V1Factory?: Address;
    dopplerERC20V1Implementation?: Address;
    v3Initializer: Address;
    v3Quoter: Address;
    lockableV3Initializer?: Address;
    v4Initializer: Address;
    v4MulticurveInitializer?: Address;
    v4ScheduledMulticurveInitializer?: Address;
    v4DecayMulticurveInitializer?: Address;
    openingAuctionInitializer?: Address;
    openingAuctionPositionManager?: Address;
    dopplerHookInitializer?: Address;
    rehypeDopplerHookInitializer?: Address;
    /**
     * @deprecated Use rehypeDopplerHookInitializer instead.
     */
    rehypeDopplerHook?: Address;
    dopplerLens: Address;
    dopplerDeployer: Address;
    poolManager: Address;
    doppler404Factory?: Address;
    v2Migrator: Address;
    v2MigratorSplit?: Address;
    v4Migrator: Address;
    v4MigratorSplit?: Address;
    dopplerHookMigrator?: Address;
    rehypeDopplerHookMigrator?: Address;
    v4MigratorHook?: Address;
    noOpMigrator?: Address;
    governanceFactory: Address;
    noOpGovernanceFactory?: Address;
    launchpadGovernanceFactory?: Address;
    streamableFeesLocker?: Address;
    streamableFeesLockerV2?: Address;
    topUpDistributor?: Address;
    universalRouter: Address;
    univ2Router02?: Address;
    permit2: Address;
    bundler?: Address;
    weth: Address;
    uniswapV2Factory?: Address;
    uniswapV3Factory?: Address;
    uniswapV4Quoter: Address;
}
declare const ADDRESSES: Record<SupportedChainId, ChainAddresses>;
/**
 * Get addresses for a specific chain
 */
declare function getAddresses(chainId: number): ChainAddresses;
/**
 * List of supported chain IDs for easy iteration/validation
 */
declare const SUPPORTED_CHAIN_IDS: SupportedChainId[];
/**
 * Runtime/type guard for narrowing a number to SupportedChainId
 */
declare function isSupportedChainId(id: number): id is SupportedChainId;

type SupportedChain = typeof mainnet | typeof sepolia | typeof arbitrum | typeof base | typeof baseSepolia | typeof ink | typeof unichain;
type SupportedPublicClient = unknown;
interface StandardTokenConfig {
    type: 'standard';
    name: string;
    symbol: string;
    tokenURI: string;
    yearlyMintRate?: bigint;
}
type DopplerERC20V1OnlyTokenConfigFields = {
    maxBalanceLimit?: bigint;
    balanceLimitEnd?: number;
    controller?: Address;
    excludedFromBalanceLimit?: Address[];
};
interface Doppler404TokenConfig {
    type: 'doppler404';
    name: string;
    symbol: string;
    baseURI: string;
    unit?: bigint;
}
type DopplerERC20V1TokenConfig = {
    type: 'dopplerERC20V1';
    name: string;
    symbol: string;
    tokenURI: string;
    /**
     * DopplerERC20V1 does not support yearly minting.
     * Set `type: 'standard'` to configure `yearlyMintRate`.
     */
    yearlyMintRate?: never;
} & DopplerERC20V1OnlyTokenConfigFields;
type InferredDopplerERC20V1TokenConfig = {
    type?: never;
    name: string;
    symbol: string;
    tokenURI: string;
    /**
     * DopplerERC20V1 does not support yearly minting.
     * Set `type: 'standard'` to configure `yearlyMintRate`.
     */
    yearlyMintRate?: never;
} & DopplerERC20V1OnlyTokenConfigFields;
type TokenConfig = StandardTokenConfig | Doppler404TokenConfig | DopplerERC20V1TokenConfig | InferredDopplerERC20V1TokenConfig;
interface SaleConfig {
    initialSupply: bigint;
    numTokensToSell: bigint;
    numeraire: Address;
}
interface StaticPoolConfig {
    startTick: number;
    endTick: number;
    fee: number;
    numPositions?: number;
    maxShareToBeSold?: bigint;
    beneficiaries?: BeneficiaryData[];
}
interface DynamicAuctionConfig {
    duration: number;
    epochLength: number;
    startTick: number;
    endTick: number;
    gamma?: number;
    minProceeds: bigint;
    maxProceeds: bigint;
    numPdSlugs?: number;
}
interface OpeningAuctionConfig$1 {
    auctionDuration: number;
    minAcceptableTickToken0: number;
    minAcceptableTickToken1: number;
    incentiveShareBps: number;
    tickSpacing: number;
    fee: number;
    minLiquidity: bigint;
    shareToAuctionBps: number;
}
interface OpeningAuctionDopplerConfig$1 {
    minProceeds: bigint;
    maxProceeds: bigint;
    startTick: number;
    endTick: number;
    epochLength: number;
    duration: number;
    gamma?: number;
    numPdSlugs?: number;
    fee: number;
    tickSpacing: number;
    startTimeOffset?: number;
    startingTime?: number;
}
interface VestingScheduleConfig {
    duration: number;
    cliffDuration: number;
}
interface VestingAllocationConfig {
    recipient: Address;
    amount: bigint;
    schedule: VestingScheduleConfig;
}
type VestingConfig = {
    duration: number;
    cliffDuration: number;
    recipients?: Address[];
    amounts?: bigint[];
    allocations?: never;
} | {
    duration?: never;
    cliffDuration?: never;
    recipients?: never;
    amounts?: never;
    allocations: VestingAllocationConfig[];
};
declare const NO_OP_ENABLED_CHAIN_IDS: readonly [1, 11155111, 42161, 8453, 84532, 130, 1301, 4663, 10143, 143];
type NoOpEnabledChainId = (typeof NO_OP_ENABLED_CHAIN_IDS)[number];
/**
 * Check if a chain supports no-op governance
 */
declare function isNoOpEnabledChain(chainId: number): chainId is NoOpEnabledChainId;
declare const LAUNCHPAD_ENABLED_CHAIN_IDS: readonly [1, 42161, 8453, 84532, 4663, 143];
type LaunchpadEnabledChainId = (typeof LAUNCHPAD_ENABLED_CHAIN_IDS)[number];
/**
 * Check if a chain supports launchpad governance
 */
declare function isLaunchpadEnabledChain(chainId: number): chainId is LaunchpadEnabledChainId;
type GovernanceDefault = {
    type: 'default';
};
interface GovernanceCustom {
    type: 'custom';
    initialVotingDelay: number;
    initialVotingPeriod: number;
    initialProposalThreshold: bigint;
}
type GovernanceNoOp = {
    type: 'noOp';
};
interface GovernanceLaunchpad {
    type: 'launchpad';
    multisig: Address;
}
type GovernanceOption<C extends SupportedChainId> = GovernanceDefault | GovernanceCustom | (C extends NoOpEnabledChainId ? GovernanceNoOp : never) | (C extends LaunchpadEnabledChainId ? GovernanceLaunchpad : never);
interface BeneficiaryData {
    beneficiary: Address;
    shares: bigint;
}
declare enum LockablePoolStatus {
    Uninitialized = 0,
    Initialized = 1,
    Locked = 2,
    Exited = 3
}
declare enum OpeningAuctionPhase {
    NotStarted = 0,
    Active = 1,
    Closed = 2,
    Settled = 3
}
declare enum OpeningAuctionStatus {
    Uninitialized = 0,
    AuctionActive = 1,
    DopplerActive = 2,
    Exited = 3
}
interface LockablePoolState {
    asset: Address;
    numeraire: Address;
    tickLower: number;
    tickUpper: number;
    maxShareToBeSold: bigint;
    totalTokensOnBondingCurve: bigint;
    status: LockablePoolStatus;
}
interface MulticurvePoolState {
    asset: Address;
    numeraire: Address;
    fee: number;
    tickSpacing: number;
    status: LockablePoolStatus;
    poolKey: V4PoolKey;
    farTick: number;
}
interface RehypeDopplerHookMigratorConfig {
    hookAddress?: Address;
    buybackDestination: Address;
    customFee: number;
    feeRoutingMode?: RehypeFeeRoutingMode | 'directBuyback' | 'routeToBeneficiaryFees';
    feeDistributionInfo?: RehypeFeeDistributionInfo;
    /**
     * @deprecated Use feeDistributionInfo.* fields instead.
     * If feeDistributionInfo is omitted, legacy percentages are mirrored to both rows.
     */
    assetBuybackPercentWad?: bigint;
    /**
     * @deprecated Use feeDistributionInfo.* fields instead.
     */
    numeraireBuybackPercentWad?: bigint;
    /**
     * @deprecated Use feeDistributionInfo.* fields instead.
     */
    beneficiaryPercentWad?: bigint;
    /**
     * @deprecated Use feeDistributionInfo.* fields instead.
     */
    lpPercentWad?: bigint;
}
interface DopplerHookMigratorConfig {
    type: 'dopplerHookMigrator';
    fee: number;
    useDynamicFee?: boolean;
    tickSpacing: number;
    lockDuration: number;
    beneficiaries: BeneficiaryData[];
    hook?: {
        hookAddress: Address;
        onInitializationCalldata?: `0x${string}`;
    };
    rehype?: RehypeDopplerHookMigratorConfig;
    proceedsSplit?: {
        recipient: Address;
        share: bigint;
    };
}
/**
 * @deprecated Use DopplerHookMigratorConfig with
 * `type: 'dopplerHookMigrator'` instead.
 */
type DopplerHookMigrationConfig = Omit<DopplerHookMigratorConfig, 'type'> & {
    type: 'dopplerHook';
};
interface ProceedsSplitConfig {
    recipient: Address;
    share: bigint;
}
interface StreamableFeesConfig {
    lockDuration: number;
    beneficiaries: BeneficiaryData[];
}
interface UniswapV2MigrationConfig {
    type: 'uniswapV2';
}
interface UniswapV2SplitMigrationConfig {
    type: 'uniswapV2Split';
    proceedsSplit?: ProceedsSplitConfig;
}
interface UniswapV4MigrationConfig {
    type: 'uniswapV4';
    fee: number;
    tickSpacing: number;
    streamableFees?: StreamableFeesConfig;
}
interface UniswapV4SplitMigrationConfig {
    type: 'uniswapV4Split';
    fee: number;
    tickSpacing: number;
    streamableFees: StreamableFeesConfig;
    proceedsSplit?: ProceedsSplitConfig;
}
type MigrationConfig = UniswapV2MigrationConfig | UniswapV2SplitMigrationConfig | UniswapV4MigrationConfig | UniswapV4SplitMigrationConfig | DopplerHookMigratorConfig | DopplerHookMigrationConfig | {
    type: 'noOp';
};
interface CreateStaticAuctionParams<C extends SupportedChainId = SupportedChainId> {
    token: TokenConfig;
    sale: SaleConfig;
    pool: StaticPoolConfig;
    vesting?: VestingConfig;
    governance: GovernanceOption<C>;
    migration: MigrationConfig;
    integrator?: Address;
    userAddress: Address;
    modules?: ModuleAddressOverrides;
    gas?: bigint;
}
interface CreateDynamicAuctionParams<C extends SupportedChainId = SupportedChainId> {
    token: TokenConfig;
    sale: SaleConfig;
    auction: DynamicAuctionConfig;
    pool: {
        fee: number;
        tickSpacing: number;
    };
    vesting?: VestingConfig;
    governance: GovernanceOption<C>;
    migration: MigrationConfig;
    integrator?: Address;
    userAddress: Address;
    startTimeOffset?: number;
    blockTimestamp?: number;
    gas?: bigint;
    modules?: ModuleAddressOverrides;
}
interface CreateOpeningAuctionParams$1<C extends SupportedChainId = SupportedChainId> {
    token: TokenConfig;
    sale: SaleConfig;
    openingAuction: OpeningAuctionConfig$1;
    doppler: OpeningAuctionDopplerConfig$1;
    vesting?: VestingConfig;
    governance: GovernanceOption<C>;
    migration: MigrationConfig;
    integrator?: Address;
    userAddress: Address;
    startTimeOffset?: number;
    startingTime?: number;
    blockTimestamp?: number;
    gas?: bigint;
    modules?: ModuleAddressOverrides;
}
interface PriceRange {
    startPrice: number;
    endPrice: number;
}
/**
 * Market cap range in USD for price configurations.
 * Used to define start and end market caps for bonding curves.
 */
interface MarketCapRange {
    /** Starting market cap in USD (e.g., 100_000 for $100k) */
    start: number;
    /** Ending market cap in USD (e.g., 10_000_000 for $10M) */
    end: number;
}
/**
 * Base configuration for market cap-based tick calculations.
 * Used by builder methods to convert market caps to ticks.
 */
interface MarketCapConfig {
    /** Target market cap range in USD */
    marketCap: MarketCapRange;
    /** Price of numeraire in USD (e.g., 3000 for ETH at $3000) */
    numerairePrice: number;
    /**
     * Token supply override. If not provided, inferred from saleConfig.initialSupply.
     * Must include decimals (e.g., parseEther('1000000000') for 1B tokens).
     */
    tokenSupply?: bigint;
    /** Token decimals (default: 18) */
    tokenDecimals?: number;
    /** Numeraire decimals (default: 18) */
    numeraireDecimals?: number;
}
/**
 * Market cap configuration for V3 Static Auctions.
 * Extends base config with V3-specific parameters.
 */
interface StaticAuctionMarketCapConfig extends MarketCapConfig {
    /** Fee tier in basis points (e.g., 10000 for 1%). Default: 10000 */
    fee?: number;
    /** Number of liquidity positions. Default: 15 */
    numPositions?: number;
    /** Maximum share of tokens to sell per position (WAD). Default: 35% */
    maxShareToBeSold?: bigint;
}
/**
 * Market cap range for V4 Dynamic Auctions (Dutch auctions).
 * Uses start/min because price descends from start to minimum.
 */
interface DynamicMarketCapRange {
    /** Starting market cap in USD - auction begins here (e.g., 500_000 for $500k) */
    start: number;
    /** Minimum market cap in USD - floor price the auction descends to (e.g., 50_000 for $50k) */
    min: number;
}
/**
 * Market cap configuration for V4 Dynamic Auctions.
 * Uses start/min (not start/end) because Dutch auctions descend from start to minimum.
 */
interface DynamicAuctionMarketCapConfig {
    /** Target market cap range (start = launch price, min = floor price) */
    marketCap: DynamicMarketCapRange;
    /** Price of numeraire in USD (e.g., 3000 for ETH at $3000) */
    numerairePrice: number;
    /**
     * Token supply override. If not provided, inferred from saleConfig.initialSupply.
     * Must include decimals (e.g., parseEther('1000000000') for 1B tokens).
     */
    tokenSupply?: bigint;
    /** Token decimals (default: 18) */
    tokenDecimals?: number;
    /** Numeraire decimals (default: 18) */
    numeraireDecimals?: number;
    /**
     * Pool fee in basis points. Default: 10000 (1%)
     *
     * V4 pools support any fee from 0 to 100,000 (10%).
     * Standard tiers (100, 500, 3000, 10000) auto-derive tickSpacing.
     * Custom fees require explicit tickSpacing parameter.
     */
    fee?: number;
    /**
     * Tick spacing for the pool. Required for custom fees.
     *
     * Must be <= 30 for Doppler pools (MAX_TICK_SPACING constraint).
     * If not provided with a standard fee tier, defaults to 30.
     */
    tickSpacing?: number;
    /** Minimum proceeds required for successful auction */
    minProceeds: bigint;
    /** Maximum proceeds cap for the auction */
    maxProceeds: bigint;
    /** Auction duration in seconds. Default: 7 days */
    duration?: number;
    /** Epoch length in seconds. Default: 3600 (1 hour) */
    epochLength?: number;
    /** Gamma (tick decay per epoch). Auto-calculated if not provided */
    gamma?: number;
    /** Number of price discovery slugs. Default: 5 */
    numPdSlugs?: number;
}
/**
 * Result of market cap parameter validation.
 */
interface MarketCapValidationResult {
    /** Whether all parameters are within normal bounds */
    valid: boolean;
    /** Warning messages for unusual but technically valid values */
    warnings: string[];
}
/**
 * Parameters for converting market cap range to ticks for V3 Static Auctions.
 */
interface StaticAuctionTickParams {
    marketCapRange: MarketCapRange;
    tokenSupply: bigint;
    numerairePriceUSD: number;
    tickSpacing: number;
    tokenDecimals?: number;
    numeraireDecimals?: number;
}
/**
 * Parameters for converting market cap range to ticks for V4 Dynamic Auctions.
 */
interface DynamicAuctionTickParams {
    marketCapRange: MarketCapRange;
    tokenSupply: bigint;
    numerairePriceUSD: number;
    numeraire: Address;
    tickSpacing: number;
    tokenDecimals?: number;
    numeraireDecimals?: number;
}
/**
 * Parameters for converting market cap range to ticks for V4 Multicurve pools.
 */
interface MulticurveTickRangeParams {
    marketCapLower: number;
    marketCapUpper: number | 'max';
    tokenSupply: bigint;
    numerairePriceUSD: number;
    tickSpacing: number;
    tokenDecimals?: number;
    numeraireDecimals?: number;
}
/**
 * Parameters for converting a single market cap to a tick for Multicurve.
 */
interface MulticurveTickParams {
    marketCapUSD: number;
    tokenSupply: bigint;
    numerairePriceUSD: number;
    tickSpacing: number;
    tokenDecimals?: number;
    numeraireDecimals?: number;
}
/**
 * Parameters for converting a tick to market cap (reverse conversion).
 */
interface TickToMarketCapParams {
    tick: number;
    tokenSupply: bigint;
    numerairePriceUSD: number;
    tokenDecimals?: number;
    numeraireDecimals?: number;
}
/**
 * Curve configuration for Multicurve pools using market cap ranges.
 * Each curve defines a market cap range and liquidity distribution.
 */
interface MulticurveMarketCapRangeCurve {
    /** Market cap range for this curve */
    marketCap: {
        /** Start market cap in USD (for the first curve, this is the launch price) */
        start: number;
        /** End market cap in USD, or 'max' for the highest contract-safe terminal tick */
        end: number | 'max';
    };
    /** Number of liquidity positions in this curve */
    numPositions: number;
    /** Share of total supply allocated to this curve (WAD, e.g., parseEther('0.3') = 30%) */
    shares: bigint;
}
/**
 * Market cap-based configuration for Multicurve pools.
 * No tick math required - just specify market caps in USD.
 */
interface MulticurveMarketCapCurvesConfig {
    /** Price of numeraire in USD (e.g., 3000 for ETH at $3000) */
    numerairePrice: number;
    /**
     * Array of curves defining market cap ranges and liquidity distribution.
     * The first curve's marketCap.start is the launch price.
     * Curves must be contiguous (no gaps allowed).
     */
    curves: MulticurveMarketCapRangeCurve[];
    /** Token supply override */
    tokenSupply?: bigint;
    /** Token decimals (default: 18) */
    tokenDecimals?: number;
    /** Numeraire decimals (default: 18) */
    numeraireDecimals?: number;
    /** Fee tier (default: FEE_TIERS.LOW) */
    fee?: number;
    /** Tick spacing (derived from fee if not provided) */
    tickSpacing?: number;
    /** Optional beneficiaries for fee streaming */
    beneficiaries?: BeneficiaryData[];
}
interface DopplerSDKConfig {
    publicClient: SupportedPublicClient;
    walletClient?: WalletClient;
    chainId: number;
}
interface PoolInfo {
    address: Address;
    tokenAddress: Address;
    numeraireAddress: Address;
    fee: number;
    liquidity: bigint;
    sqrtPriceX96: bigint;
}
interface HookInfo {
    hookAddress: Address;
    tokenAddress: Address;
    numeraireAddress: Address;
    poolId: string;
    currentEpoch: number;
    totalProceeds: bigint;
    totalTokensSold: bigint;
    earlyExit: boolean;
    insufficientProceeds: boolean;
    startingTime: bigint;
    endingTime: bigint;
    epochLength: bigint;
    minimumProceeds: bigint;
    maximumProceeds: bigint;
}
interface OpeningAuctionState {
    numeraire: Address;
    auctionStartTime: bigint;
    auctionEndTime: bigint;
    auctionTokens: bigint;
    dopplerTokens: bigint;
    status: OpeningAuctionStatus;
    openingAuctionHook: Address;
    dopplerHook: Address;
    openingAuctionPoolKey: V4PoolKey;
    dopplerInitData: `0x${string}`;
    isToken0: boolean;
}
interface OpeningAuctionCreateResult {
    tokenAddress: Address;
    openingAuctionHookAddress: Address;
    transactionHash: string;
    createParams: CreateParams;
    minedSalt: `0x${string}`;
}
interface OpeningAuctionCompleteResult {
    asset: Address;
    dopplerHookAddress: Address;
    transactionHash: string;
    dopplerSalt: `0x${string}`;
}
interface QuoteResult {
    amountOut: bigint;
    priceImpact: number;
    fee: bigint;
    route: string[];
}
interface LockableV3InitializerParams {
    fee: number;
    tickLower: number;
    tickUpper: number;
    numPositions: number;
    maxShareToBeSold: bigint;
    beneficiaries: BeneficiaryData[];
}
interface MulticurveCurve {
    tickLower: number;
    tickUpper: number;
    numPositions: number;
    shares: bigint;
}
type MulticurveMarketCapPreset = 'low' | 'medium' | 'high';
interface V4PoolKey {
    currency0: Address;
    currency1: Address;
    fee: number;
    tickSpacing: number;
    hooks: Address;
}
interface RehypeFeeDistributionInfo {
    assetFeesToAssetBuybackWad: bigint;
    assetFeesToNumeraireBuybackWad: bigint;
    assetFeesToBeneficiaryWad: bigint;
    assetFeesToLpWad: bigint;
    numeraireFeesToAssetBuybackWad: bigint;
    numeraireFeesToNumeraireBuybackWad: bigint;
    numeraireFeesToBeneficiaryWad: bigint;
    numeraireFeesToLpWad: bigint;
}
declare enum RehypeFeeRoutingMode {
    DirectBuyback = 0,
    RouteToBeneficiaryFees = 1
}
type RehypeFeeRoutingModeInput = RehypeFeeRoutingMode | 'directBuyback' | 'routeToBeneficiaryFees';
type RehypeDopplerHookInitializerCommonConfig = {
    hookAddress: Address;
    startFee?: number;
    endFee?: number;
    durationSeconds?: number | bigint;
    startingTime?: number | bigint | Date;
    feeDistributionInfo?: RehypeFeeDistributionInfo;
    /**
     * @deprecated Use startFee/endFee instead. When provided alone, maps to startFee=endFee=customFee.
     */
    customFee?: number;
    /**
     * @deprecated Use feeDistributionInfo.* fields instead.
     * If feeDistributionInfo is omitted, legacy percentages are mirrored to both rows.
     */
    assetBuybackPercentWad?: bigint;
    /**
     * @deprecated Use feeDistributionInfo.* fields instead.
     */
    numeraireBuybackPercentWad?: bigint;
    /**
     * @deprecated Use feeDistributionInfo.* fields instead.
     */
    beneficiaryPercentWad?: bigint;
    /**
     * @deprecated Use feeDistributionInfo.* fields instead.
     */
    lpPercentWad?: bigint;
    graduationCalldata?: `0x${string}`;
    graduationMarketCap?: number;
    numerairePrice?: number;
    farTick?: number;
};
type RehypeBuybackDestinationConfig = {
    buybackDestination?: Address;
    feeBeneficiaries?: never;
    feeRoutingMode?: RehypeFeeRoutingModeInput;
};
type RehypeFeeBeneficiariesConfig = {
    buybackDestination?: Address;
    feeBeneficiaries: [BeneficiaryData, ...BeneficiaryData[]];
    feeRoutingMode?: RehypeFeeRoutingMode.RouteToBeneficiaryFees | 'routeToBeneficiaryFees';
};
/**
 * Rehype fee distribution controller requirements:
 *
 * `buybackDestination` is encoded as the hook's `buybackDst`: it is the only
 * address authorized to call `setFeeDistribution` and also receives
 * direct-buyback proceeds and legacy empty-beneficiary fees. Configured
 * `feeBeneficiaries` control beneficiary fee recipients but do not grant that
 * authority.
 *
 * Every Rehype configuration requires an explicit fee distribution controller.
 * Direct factory callers must set `buybackDestination`. Builder callers may
 * instead use `withFeeDistributionController`. These options configure the
 * same on-chain field and cannot be used together.
 *
 * Governance configuration, governance factory results, fee beneficiaries,
 * and LP reinvestment do not determine or provide the controller.
 */
type RehypeDopplerHookInitializerConfig = RehypeDopplerHookInitializerCommonConfig & (RehypeBuybackDestinationConfig | RehypeFeeBeneficiariesConfig);
/** @deprecated Use RehypeDopplerHookInitializerConfig instead. */
type RehypeDopplerHookConfig = RehypeDopplerHookInitializerConfig;
interface MulticurveDecayFeeSchedule {
    startingTime: number;
    startFee: number;
    endFee: number;
    lastFee: number;
    durationSeconds: number;
}
type MulticurveInitializerConfig = {
    type: 'dopplerHookInitializer';
} | {
    /** @deprecated Use 'dopplerHookInitializer' instead. */
    type: 'dopplerHook';
} | {
    type: 'standard';
} | {
    type: 'scheduled';
    startTime: number;
} | {
    type: 'decay';
    startTime: number;
    startFee: number;
    durationSeconds: number;
} | {
    type: 'rehype';
    config: RehypeDopplerHookInitializerConfig;
};
/**
 * Bundler custody schedule for a multicurve dev buy.
 *
 * Durations are seconds. A permissionless claim changes who may trigger the
 * claim, never the recipient.
 */
interface MulticurveDevBuyVestingConfig {
    permissionlessClaim: boolean;
    vestingDuration: bigint;
    cliffDuration: bigint;
}
/** Exact-input purchase executed atomically with multicurve market creation. */
interface MulticurveDevBuyConfig {
    exactAmountIn: bigint;
    recipient: Address;
    vesting: MulticurveDevBuyVestingConfig;
}
interface CreateMulticurveParams<C extends SupportedChainId = SupportedChainId> {
    token: TokenConfig;
    sale: SaleConfig;
    pool: {
        fee: number;
        tickSpacing: number;
        curves: MulticurveCurve[];
        beneficiaries?: BeneficiaryData[];
    };
    initializer?: MulticurveInitializerConfig;
    /**
     * @deprecated Use initializer: { type: 'scheduled', startTime } instead.
     * Retained for backwards compatibility.
     */
    schedule?: {
        startTime: number;
    };
    /**
     * @deprecated Use initializer: { type: 'rehype', config } instead.
     * Retained for backwards compatibility.
     */
    dopplerHook?: RehypeDopplerHookConfig;
    vesting?: VestingConfig;
    /** Optional exact-input purchase executed atomically through Bundler. */
    devBuy?: MulticurveDevBuyConfig;
    governance: GovernanceOption<C>;
    migration: MigrationConfig;
    integrator?: Address;
    userAddress: Address;
    salt?: Hex;
    modules?: ModuleAddressOverrides;
    gas?: bigint;
}
interface CreateParams {
    initialSupply: bigint;
    numTokensToSell: bigint;
    numeraire: Address;
    tokenFactory: Address;
    tokenFactoryData: `0x${string}`;
    governanceFactory: Address;
    governanceFactoryData: `0x${string}`;
    poolInitializer: Address;
    poolInitializerData: `0x${string}`;
    liquidityMigrator: Address;
    liquidityMigratorData: `0x${string}`;
    integrator: Address;
    salt: `0x${string}`;
}
interface PrepareCreateMulticurveOptions {
    account: Address;
}
type MulticurveCreateGasEstimate = {
    status: 'estimated';
    gas: bigint;
} | {
    status: 'unavailable';
};
interface MulticurveCreatePrediction {
    tokenAddress: Address;
    poolOrHookAddress: Address;
    governanceAddress: Address;
    timelockAddress: Address;
    migrationPoolAddress?: Address;
    poolKey: V4PoolKey;
    poolId: Hex;
    tokenIsCurrency0: boolean;
}
interface PreparedMulticurveTransaction {
    to: Address;
    data: Hex;
    value: bigint;
}
/** Dev-buy details returned by preparation and contract simulation. */
interface PreparedMulticurveDevBuy extends MulticurveDevBuyConfig {
    bundler: Address;
    simulatedAmountOut: bigint;
}
interface PreparedMulticurveCreate<C extends SupportedChainId = SupportedChainId> {
    chainId: C;
    account: Address;
    airlock: Address;
    createParams: CreateParams;
    prediction: MulticurveCreatePrediction;
    transaction: PreparedMulticurveTransaction;
    approvalTransaction?: PreparedMulticurveTransaction;
    devBuy?: PreparedMulticurveDevBuy;
    gasEstimate: MulticurveCreateGasEstimate;
}
interface SimulatedMulticurveCreate<_C extends SupportedChainId = SupportedChainId> {
    createParams: CreateParams;
    tokenAddress: Address;
    poolId: Hex;
    gasEstimate?: bigint;
    devBuy?: PreparedMulticurveDevBuy;
    execute: () => Promise<MulticurveCreateResult>;
}
/** Dev-buy details verified from the executed Bundler receipt. */
interface MulticurveDevBuyResult extends MulticurveDevBuyConfig {
    bundler: Address;
    amountOut: bigint;
}
interface MulticurveCreateResult {
    tokenAddress: Address;
    poolId: Hex;
    transactionHash: Hash;
    approvalTransactionHash?: Hash;
    devBuy?: MulticurveDevBuyResult;
}
interface ModuleAddressOverrides {
    airlock?: Address;
    bundler?: Address;
    tokenFactory?: Address;
    dopplerERC20V1Factory?: Address;
    v3Initializer?: Address;
    lockableV3Initializer?: Address;
    v4Initializer?: Address;
    v4MulticurveInitializer?: Address;
    v4ScheduledMulticurveInitializer?: Address;
    v4DecayMulticurveInitializer?: Address;
    openingAuctionInitializer?: Address;
    openingAuctionPositionManager?: Address;
    dopplerHookInitializer?: Address;
    rehypeDopplerHookInitializer?: Address;
    /**
     * @deprecated Use rehypeDopplerHookInitializer instead.
     */
    rehypeDopplerHook?: Address;
    governanceFactory?: Address;
    poolManager?: Address;
    dopplerDeployer?: Address;
    v2Migrator?: Address;
    v2MigratorSplit?: Address;
    v4Migrator?: Address;
    v4MigratorSplit?: Address;
    dopplerHookMigrator?: Address;
    rehypeDopplerHookMigrator?: Address;
    noOpMigrator?: Address;
}

type MigrationEncoder = (config: MigrationConfig) => Hex;
declare class DopplerFactory<C extends SupportedChainId = SupportedChainId> {
    private publicClient;
    private walletClient?;
    private chainId;
    private customMigrationEncoder?;
    constructor(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, chainId: C);
    private hasCustomV2Schedules;
    private usesDerc20V2Vesting;
    private resolveVestingAllocations;
    private validateDopplerERC20V1TokenFactoryData;
    private validateUint64LikeNumber;
    private validateUint48LikeNumber;
    private resolveDopplerERC20V1TokenFactoryData;
    private isDopplerERC20V1BalanceLimitActive;
    private usesDefaultDopplerERC20V1Integration;
    private resolveGovernanceBalanceLimitExclusions;
    private resolveGovernanceFactoryAddress;
    private shouldAutoExcludeGovernanceTimelock;
    private resolveMigrationLockerBalanceLimitExclusions;
    private withDopplerERC20V1EncodedBalanceLimitExclusions;
    private withSimulationGovernanceTimelockExclusion;
    private withDopplerERC20V1BalanceLimitExclusions;
    private deriveCreate2Address;
    private predictDopplerERC20V1TokenAddress;
    private computeUniswapV2PairAddress;
    private computeUniswapV3PoolAddress;
    private resolveStaticV3PoolExclusion;
    private resolveUniswapV2MigrationPairExclusion;
    private mergeDopplerERC20V1BalanceLimitExclusions;
    private resolveV2VestingSchedules;
    private resolveStandardTokenFactoryMode;
    private assertStandardTokenFactoryCompatibility;
    private assertDoppler404Compatibility;
    private buildStandardTokenFactoryData;
    private encodeStandardTokenFactoryData;
    private encodeDopplerERC20V1TokenFactoryData;
    private computeSoladyCloneInitCodeHash;
    private computeStandardTokenInitHash;
    /**
     * Set a custom migration data encoder function
     * @param encoder Custom function to encode migration data
     * @returns The factory instance for method chaining
     */
    withCustomMigrationEncoder(encoder: MigrationEncoder): this;
    encodeCreateStaticAuctionParams(params: CreateStaticAuctionParams<C>): Promise<CreateParams>;
    /**
     * Simulate a static auction creation and return predicted addresses.
     */
    simulateCreateStaticAuction(params: CreateStaticAuctionParams<C>): Promise<{
        createParams: CreateParams;
        asset: Address;
        pool: Address;
        gasEstimate?: bigint;
        /** Execute the create with the same params used in simulation (guarantees address match) */
        execute: () => Promise<{
            poolAddress: Address;
            tokenAddress: Address;
            transactionHash: string;
        }>;
    }>;
    /**
     * Create a new static auction (using Uniswap V3 for initial liquidity)
     * @param params Configuration for the static auction
     * @returns The address of the created pool and token
     */
    createStaticAuction(params: CreateStaticAuctionParams<C>, options?: {
        _createParams?: CreateParams;
    }): Promise<{
        poolAddress: Address;
        tokenAddress: Address;
        transactionHash: string;
    }>;
    /**
     * Generate a random salt based on user address
     */
    private generateRandomSalt;
    /**
     * Extract actual deployed addresses from Create event logs.
     * This is the source of truth - what actually deployed on-chain.
     * @param receipt Transaction receipt containing logs
     * @returns Token and pool/hook addresses from the Create event, or null if not found
     */
    private extractAddressesFromCreateEvent;
    /**
     * Iteratively mine a salt that ensures the newly created token sorts after the numeraire.
     * This mirrors the legacy SDK behaviour so tick configuration can assume the numeraire is token0.
     */
    private mineTokenOrder;
    encodeCreateDynamicAuctionParams(params: CreateDynamicAuctionParams<C>): Promise<{
        createParams: CreateParams;
        hookAddress: Address;
        tokenAddress: Address;
    }>;
    /**
     * Create a new dynamic auction (using Uniswap V4 hook for gradual Dutch auction)
     * @param params Configuration for the dynamic auction
     * @returns The address of the created hook and token
     */
    createDynamicAuction(params: CreateDynamicAuctionParams<C>, options?: {
        _createParams?: CreateParams;
    }): Promise<{
        hookAddress: Address;
        tokenAddress: Address;
        poolId: string;
        transactionHash: string;
    }>;
    /**
     * Simulate a dynamic auction creation and return predicted addresses and poolId.
     * Useful for clients that need the hook/token/poolId before submitting the tx.
     */
    simulateCreateDynamicAuction(params: CreateDynamicAuctionParams<C>): Promise<{
        createParams: CreateParams;
        hookAddress: Address;
        tokenAddress: Address;
        poolId: string;
        gasEstimate?: bigint;
        /** Execute the create with the same params used in simulation (guarantees address match) */
        execute: () => Promise<{
            hookAddress: Address;
            tokenAddress: Address;
            poolId: string;
            transactionHash: string;
        }>;
    }>;
    encodeCreateOpeningAuctionParams(params: CreateOpeningAuctionParams$1<C>): Promise<{
        createParams: CreateParams;
        hookAddress: Address;
        tokenAddress: Address;
        minedSalt: Hash;
    }>;
    simulateCreateOpeningAuction(params: CreateOpeningAuctionParams$1<C>): Promise<{
        createParams: CreateParams;
        openingAuctionHookAddress: Address;
        tokenAddress: Address;
        minedSalt: Hash;
        gasEstimate?: bigint;
        execute: () => Promise<OpeningAuctionCreateResult>;
    }>;
    createOpeningAuction(params: CreateOpeningAuctionParams$1<C>, options?: {
        _createParams?: CreateParams;
        _minedSalt?: Hash;
    }): Promise<OpeningAuctionCreateResult>;
    simulateCompleteOpeningAuction(args: {
        asset: Address;
        initializerAddress?: Address;
        dopplerSalt?: Hash;
        blockTimestamp?: number;
    }): Promise<{
        asset: Address;
        dopplerSalt: Hash;
        dopplerHookAddress: Address;
        gasEstimate?: bigint;
        execute: () => Promise<OpeningAuctionCompleteResult>;
    }>;
    completeOpeningAuction(args: {
        asset: Address;
        initializerAddress?: Address;
        dopplerSalt?: Hash;
        autoSettle?: boolean;
        blockTimestamp?: number;
    }): Promise<OpeningAuctionCompleteResult>;
    simulateRecoverOpeningAuctionIncentives(args: {
        asset: Address;
        initializerAddress?: Address;
        account?: Address | Account;
    }): Promise<{
        request: unknown;
    }>;
    recoverOpeningAuctionIncentives(args: {
        asset: Address;
        initializerAddress?: Address;
    }): Promise<Hash>;
    simulateSweepOpeningAuctionIncentives(args: {
        asset: Address;
        initializerAddress?: Address;
        account?: Address | Account;
    }): Promise<{
        request: unknown;
    }>;
    sweepOpeningAuctionIncentives(args: {
        asset: Address;
        initializerAddress?: Address;
    }): Promise<Hash>;
    private resolveOpeningAuctionInitializerAddress;
    private normalizeOpeningAuctionState;
    private decodeDopplerInitData;
    private encodeDopplerInitData;
    private alignTickTowardZero;
    private alignTickForDirection;
    private mineDopplerCompletionSalt;
    private mineDopplerHookSalt;
    private mineOpeningAuctionHookAddress;
    private isCreateGasRevert;
    private resolveInternalCreateGasEstimate;
    private resolveCreateGasEstimate;
    private isDoppler404Token;
    private isDopplerERC20V1Token;
    /**
     * Encode migration data based on the MigrationConfig
     * This replaces the manual encoding methods from the old SDKs
     */
    private encodeMigrationData;
    /**
     * Encode create params for Uniswap V4 Multicurve initializer/migrator flow
     */
    private normalizeUint32;
    private validateV4StreamableFeesConfig;
    private validateProceedsSplitConfig;
    private resolveMulticurveInitializerMode;
    encodeCreateMulticurveParams(params: CreateMulticurveParams<C>): CreateParams;
    private resolveBundlerAddress;
    private ensureDevBuyInitializerCompatibility;
    private parseBundleSimulation;
    private resolveFinalMulticurveCreate;
    private buildDevBuyTransaction;
    private readDevBuyAllowance;
    private estimateDevBuyGas;
    prepareCreateMulticurve(params: CreateMulticurveParams<C>, options: PrepareCreateMulticurveOptions): Promise<PreparedMulticurveCreate<C>>;
    simulateCreateMulticurve(params: CreateMulticurveParams<C>): Promise<SimulatedMulticurveCreate<C>>;
    createMulticurve(params: CreateMulticurveParams<C>, options?: {
        _createParams?: CreateParams;
    }): Promise<MulticurveCreateResult>;
    /**
     * Normalize user-provided multicurve positions and ensure they satisfy SDK constraints
     */
    private normalizeMulticurveCurves;
    private roundMaxTickDown;
    private validateVestingConfig;
    private validateStaticAuctionParams;
    /**
     * Validate dynamic auction parameters
     */
    private validateDynamicAuctionParams;
    private validateOpeningAuctionParams;
    private validateMulticurveDevBuy;
    /**
     * Validate multicurve auction parameters
     */
    private validateMulticurveParams;
    /**
     * Get the appropriate migrator address based on migration config
     * Allows override via ModuleAddressOverrides when provided in params.
     */
    private resolveUniswapV2Migrator;
    private getMigratorAddress;
    private normalizePoolKey;
    /**
     * Mines a salt and hook address with the appropriate flags
     *
     * This method iterates through possible salt values to find a combination that:
     * - Produces a hook address with required Doppler flags
     * - Maintains proper token ordering relative to numeraire
     * - Ensures deterministic deployment addresses
     *
     * @param params - Parameters for hook address mining
     * @returns Tuple of [salt, hook address, token address, pool data, token data]
     * @throws {Error} If no valid salt can be found within the search limit
     * @private
     */
    private mineHookAddress;
    /**
     * Helper to convert hex string to Uint8Array
     * @private
     */
    private hexToBytes;
    /**
     * Helper to convert Uint8Array to hex string
     * @private
     */
    private bytesToHex;
    /**
     * Pre-compute CREATE2 buffer with constant prefix for fast mining
     * Buffer layout: 0xff (1 byte) + deployer (20 bytes) + salt (32 bytes) + initCodeHash (32 bytes) = 85 bytes
     * @private
     */
    private prepareCreate2Buffer;
    /**
     * Update salt in pre-computed CREATE2 buffer (bytes 21-52)
     * Uses direct byte manipulation instead of string conversion
     * @private
     */
    private updateSaltInBuffer;
    /**
     * Compute CREATE2 address from pre-computed buffer (fast version for mining)
     * Returns raw lowercase address without checksum for comparison
     * @private
     */
    private computeCreate2AddressFast;
    /**
     * Compute V4 pool ID from pool key components
     */
    private computePoolId;
    /**
     * Compute the complete V4 multicurve pool identity from the same pool-key
     * fields the initializer will register on-chain.
     */
    private computeMulticurvePoolIdentity;
}

/**
 * StaticAuction class for interacting with static auctions (Uniswap V3 based)
 *
 * Static auctions use a fixed price range on Uniswap V3 for initial liquidity bootstrapping.
 * This is ideal for simple, predictable price discovery events.
 */
declare class StaticAuction {
    private client;
    private poolAddress;
    private get rpc();
    constructor(client: SupportedPublicClient, poolAddress: Address);
    /**
     * Get the pool address
     */
    getAddress(): Address;
    /**
     * Get current pool information
     */
    getPoolInfo(): Promise<PoolInfo>;
    /**
     * Get the token address for this auction
     */
    getTokenAddress(): Promise<Address>;
    /**
     * Check if the auction has graduated (ready for migration)
     */
    hasGraduated(): Promise<boolean>;
    /**
     * Get the current price in the pool
     * Returns the price of token in terms of numeraire (token/numeraire)
     */
    getCurrentPrice(): Promise<bigint>;
    /**
     * Get total liquidity in the pool
     */
    getTotalLiquidity(): Promise<bigint>;
    private isRegisteredAirlockAsset;
}

/**
 * DynamicAuction class for interacting with dynamic auctions (Uniswap V4 hook based)
 *
 * Dynamic auctions use a Uniswap V4 hook to create a gradual Dutch auction
 * where the price moves dynamically over time according to set parameters.
 */
declare class DynamicAuction {
    private client;
    private hookAddress;
    private get rpc();
    constructor(client: SupportedPublicClient, hookAddress: Address);
    /**
     * Wait for a transaction to be confirmed and the contract to be ready for reads
     * @param hash - Transaction hash to wait for
     * @param confirmations - Number of block confirmations to wait for (default: 2)
     */
    waitForDeployment(hash: Hex, confirmations?: number): Promise<void>;
    /**
     * Get the hook address
     */
    getAddress(): Address;
    /**
     * Get current hook information
     */
    getHookInfo(): Promise<HookInfo>;
    /**
     * Get the token address for this auction
     */
    getTokenAddress(): Promise<Address>;
    /**
     * Get the pool ID for this auction
     */
    getPoolId(): Promise<string>;
    /**
     * Check if the auction has graduated (ready for migration)
     */
    hasGraduated(): Promise<boolean>;
    /**
     * Get the current epoch
     */
    getCurrentEpoch(): Promise<number>;
    /**
     * Get the current price in the auction
     * Returns the current tick based on the epoch and gamma parameters
     */
    getCurrentPrice(): Promise<bigint>;
    /**
     * Get total proceeds collected so far
     */
    getTotalProceeds(): Promise<bigint>;
    /**
     * Check if the auction ended early due to max proceeds
     */
    hasEndedEarly(): Promise<boolean>;
    private readHookState;
}

interface MulticurvePendingFees {
    fees0: bigint;
    fees1: bigint;
}
interface MulticurveTokenPendingFees extends MulticurvePendingFees {
    tokenAddress: Address;
}

/**
 * MulticurvePool class for interacting with V4 multicurve pools
 *
 * Multicurve pools use the V4 multicurve initializer which supports:
 * - Multiple bonding curves with different price ranges
 * - Fee collection for configured beneficiaries
 * - No-migration lockable liquidity
 *
 * Note: V4 pools don't have their own contract addresses. The token address
 * is used as the lookup key to retrieve pool state from the initializer contract.
 *
 * Terminology: The contracts call the created token "asset" (paired against "numeraire", e.g., WETH).
 * We use "tokenAddress" in the SDK for consistency.
 */
declare class MulticurvePool {
    private client;
    private walletClient?;
    private tokenAddress;
    private get rpc();
    constructor(client: SupportedPublicClient, walletClient: WalletClient | undefined, tokenAddress: Address);
    /**
     * Get the token address for this pool
     * This is also the lookup key used to retrieve pool state from the initializer
     * (Called "asset" in the contracts, but we use "tokenAddress" for SDK consistency)
     */
    getTokenAddress(): Address;
    /**
     * Get current pool state from the multicurve initializer
     *
     * Automatically discovers which initializer (standard, scheduled, decay, or
     * doppler-hook) contains the pool.
     */
    getState(): Promise<MulticurvePoolState>;
    /**
     * Find which initializer contains this pool and return both the address and state.
     *
     * Tries v4MulticurveInitializer first (more common), then falls back to
     * v4ScheduledMulticurveInitializer, v4DecayMulticurveInitializer, and
     * dopplerHookInitializer if needed.
     */
    private findInitializerForPool;
    /**
     * Collect fees from a locked initializer-side pool.
     *
     * This function can be called by any account to pull pool fees into the
     * initializer. If the caller is a configured beneficiary, their pending share
     * is released as part of the same transaction.
     *
     * @returns Object containing the contract's collectFees return values and the transaction hash.
     * The returned fee amounts are newly collected pool fees, not necessarily the caller's beneficiary payout.
     */
    collectFees(): Promise<{
        fees0: bigint;
        fees1: bigint;
        transactionHash: Hash;
    }>;
    /**
     * Preview pending fees for a beneficiary on an initializer-side multicurve pool.
     */
    getPendingFees(beneficiary: Address): Promise<MulticurvePendingFees>;
    /**
     * Get the numeraire address for this pool
     */
    getNumeraireAddress(): Promise<Address>;
    /**
     * Get the decay fee schedule for dynamic-fee multicurve pools.
     *
     * Returns `null` when the pool is not using dynamic fees.
     */
    getFeeSchedule(): Promise<MulticurveDecayFeeSchedule | null>;
}

type RehypePendingFees = {
    readonly mode: 'feesManager';
    readonly fees0: bigint;
    readonly fees1: bigint;
} | {
    readonly mode: 'unsupported';
    readonly fees0: 0n;
    readonly fees1: 0n;
} | {
    readonly mode: 'notConfigured';
    readonly fees0: 0n;
    readonly fees1: 0n;
};
interface MulticurveTokenPendingFeeBreakdown {
    readonly tokenAddress: Address;
    readonly poolInitializerFees: MulticurvePendingFees;
    readonly rehypeFees: RehypePendingFees;
}

interface MulticurveFeesOptions {
    readonly tokenBatchSize?: number;
}
declare class MulticurveFees {
    private readonly client;
    private readonly tokenAddresses;
    private readonly options;
    constructor(client: SupportedPublicClient, _walletClient: WalletClient | undefined, tokenAddresses: readonly Address[], options?: MulticurveFeesOptions);
    getPendingFees(beneficiary: Address): Promise<readonly MulticurveTokenPendingFees[]>;
    getPendingFees(beneficiary: Address, options: MulticurveFeesOptions): Promise<readonly MulticurveTokenPendingFees[]>;
    getPendingFees(beneficiary: Address, tokenAddresses: readonly Address[]): Promise<readonly MulticurveTokenPendingFees[]>;
    getPendingFees(beneficiary: Address, tokenAddresses: readonly Address[], options: MulticurveFeesOptions): Promise<readonly MulticurveTokenPendingFees[]>;
    getPendingFeeBreakdown(beneficiary: Address): Promise<readonly MulticurveTokenPendingFeeBreakdown[]>;
    getPendingFeeBreakdown(beneficiary: Address, options: MulticurveFeesOptions): Promise<readonly MulticurveTokenPendingFeeBreakdown[]>;
    getPendingFeeBreakdown(beneficiary: Address, tokenAddresses: readonly Address[]): Promise<readonly MulticurveTokenPendingFeeBreakdown[]>;
    getPendingFeeBreakdown(beneficiary: Address, tokenAddresses: readonly Address[], options: MulticurveFeesOptions): Promise<readonly MulticurveTokenPendingFeeBreakdown[]>;
}

interface RehypeFeeSchedule {
    startingTime: number;
    startFee: number;
    endFee: number;
    lastFee: number;
    durationSeconds: number;
}
interface RehypeHookFees {
    fees0: bigint;
    fees1: bigint;
    beneficiaryFees0: bigint;
    beneficiaryFees1: bigint;
    airlockOwnerFees0: bigint;
    airlockOwnerFees1: bigint;
    customFee: number;
}
interface RehypePoolInfo {
    asset: Address;
    numeraire: Address;
    buybackDst: Address;
}
interface RehypePosition {
    tickLower: number;
    tickUpper: number;
    liquidity: bigint;
    salt: Hex;
}

declare class RehypeDopplerHookInitializer {
    private readonly client;
    private readonly walletClient?;
    private readonly hookAddress;
    private get rpc();
    constructor(client: SupportedPublicClient, walletClient: WalletClient | undefined, hookAddress: Address);
    getAddress(): Address;
    collectFees(asset: Address): Promise<{
        amount0: bigint;
        amount1: bigint;
        transactionHash: Hash;
    }>;
    /**
     * Collect fees and release the caller's pending beneficiary share.
     *
     * @returns The FeesManager `collectFees` return values and transaction hash.
     * The fee amounts are newly collected pool fees, not necessarily the caller's
     * beneficiary payout.
     */
    claimFees(poolId: Hex, options?: {
        gas?: bigint;
    }): Promise<{
        fees0: bigint;
        fees1: bigint;
        transactionHash: Hash;
    }>;
    getPendingFees(poolId: Hex, beneficiary: Address): Promise<MulticurvePendingFees>;
    updateBeneficiary(poolId: Hex, newBeneficiary: Address): Promise<{
        transactionHash: Hash;
    }>;
    claimAirlockOwnerFees(asset: Address): Promise<{
        fees0: bigint;
        fees1: bigint;
        transactionHash: Hash;
    }>;
    /**
     * Replace a pool's complete fee distribution matrix.
     *
     * The connected wallet must be the pool's configured fee distribution
     * controller (`buybackDst`). The asset-fee allocations and numeraire-fee
     * allocations must each sum to WAD.
     *
     * @returns The confirmed transaction hash.
     */
    setFeeDistribution(poolId: Hex, feeDistributionInfo: RehypeFeeDistributionInfo): Promise<{
        transactionHash: Hash;
    }>;
    getFeeDistributionInfo(poolId: Hex): Promise<RehypeFeeDistributionInfo>;
    getFeeRoutingMode(poolId: Hex): Promise<number>;
    getFeeSchedule(poolId: Hex): Promise<RehypeFeeSchedule>;
    getHookFees(poolId: Hex): Promise<RehypeHookFees>;
    getPoolInfo(poolId: Hex): Promise<RehypePoolInfo>;
    private requireWalletClient;
}

/** @deprecated Use RehypeDopplerHookInitializer instead. */
declare const RehypeDopplerHook: typeof RehypeDopplerHookInitializer;
/** @deprecated Use RehypeDopplerHookInitializer instead. */
type RehypeDopplerHook = RehypeDopplerHookInitializer;

declare class RehypeDopplerHookMigrator {
    private client;
    private walletClient?;
    private hookAddress;
    private get rpc();
    constructor(client: SupportedPublicClient, walletClient: WalletClient | undefined, hookAddress: Address);
    getAddress(): Address;
    collectFees(asset: Address): Promise<{
        amount0: bigint;
        amount1: bigint;
        transactionHash: Hash;
    }>;
    claimAirlockOwnerFees(asset: Address): Promise<{
        fees0: bigint;
        fees1: bigint;
        transactionHash: Hash;
    }>;
    setFeeDistribution(poolId: Hex, feeDistributionInfo: RehypeFeeDistributionInfo): Promise<Hash>;
    getFeeDistributionInfo(poolId: Hex): Promise<RehypeFeeDistributionInfo>;
    getFeeRoutingMode(poolId: Hex): Promise<number>;
    getHookFees(poolId: Hex): Promise<RehypeHookFees>;
    getPoolInfo(poolId: Hex): Promise<RehypePoolInfo>;
    getPosition(poolId: Hex): Promise<RehypePosition>;
}

interface OpeningAuctionPosition {
    owner: Address;
    tickLower: number;
    tickUpper: number;
    liquidity: bigint;
    rewardDebtX128: bigint;
    hasClaimedIncentives: boolean;
}
interface OpeningAuctionSettlementData {
    clearingTick: number;
    totalTokensSold: bigint;
    totalProceeds: bigint;
    totalAuctionTokens: bigint;
    incentiveTokensTotal: bigint;
}
interface OpeningAuctionIncentiveData {
    incentiveTokensTotal: bigint;
    totalIncentivesClaimed: bigint;
    cachedTotalWeightedTimeX128: bigint;
    incentivesClaimDeadline: bigint;
}
interface OpeningAuctionBidConstraints {
    minLiquidity: bigint;
    minAcceptableTickToken0: number;
    minAcceptableTickToken1: number;
}
interface OpeningAuctionAuctionSettledEvent {
    clearingTick: number;
    tokensSold: bigint;
    proceeds: bigint;
    transactionHash: Hash;
    blockNumber: bigint;
    logIndex: number;
}
interface OpeningAuctionWatchSettlementOptions {
    fromBlock?: bigint;
    poll?: boolean;
    pollingInterval?: number;
    strict?: boolean;
    onError?: (error: Error) => void;
    onSettled: (event: OpeningAuctionAuctionSettledEvent) => void;
}
declare class OpeningAuction {
    private publicClient;
    private walletClient?;
    private hookAddress;
    private get rpc();
    constructor(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, hookAddress: Address);
    getAddress(): Address;
    getPositionManager(): Promise<Address>;
    getPhase(): Promise<number>;
    getAuctionTimes(): Promise<{
        auctionStartTime: bigint;
        auctionEndTime: bigint;
        incentivesClaimDeadline: bigint;
    }>;
    getSettlementData(): Promise<OpeningAuctionSettlementData>;
    getIncentiveData(): Promise<OpeningAuctionIncentiveData>;
    getPositionHarvestedTime(positionId: bigint): Promise<bigint>;
    getPosition(positionId: bigint): Promise<OpeningAuctionPosition>;
    getEstimatedClearingTick(): Promise<number>;
    getLiquidityAtTick(tick: number): Promise<bigint>;
    getNextPositionId(): Promise<bigint>;
    getOwnerPositionIdAt(owner: Address, index: bigint): Promise<bigint>;
    getIsToken0(): Promise<boolean>;
    getPoolKey(): Promise<V4PoolKey>;
    getMinLiquidity(): Promise<bigint>;
    getMinAcceptableTickToken0(): Promise<number>;
    getMinAcceptableTickToken1(): Promise<number>;
    getBidConstraints(): Promise<OpeningAuctionBidConstraints>;
    /**
     * Return position IDs owned by the given address with non-zero liquidity.
     *
     * Strategy:
     * 1) Enumerate owner-indexed positions via `ownerPositions(owner, index)`.
     * 2) Stop when the first out-of-bounds index is reached.
     */
    getOwnerPositions(owner: Address): Promise<bigint[]>;
    private getOwnerPositionIdsIndexed;
    /**
     * Return whether a position is in range.
     *
     * Prefers contract-native `isInRange` when available, and falls back to
     * client-side reconstruction for compatibility.
     */
    isInRange(positionId: bigint): Promise<boolean>;
    calculateIncentives(positionId: bigint): Promise<bigint>;
    /**
     * Compute position ID client-side using computePositionKey + positionKeyToId read.
     */
    getPositionId(args: {
        owner: Address;
        tickLower: number;
        tickUpper: number;
        salt: Hash;
    }): Promise<bigint>;
    getPositionIdFromKey(positionKey: Hash): Promise<bigint>;
    estimateSettleAuctionGas(account?: Address | Account): Promise<bigint>;
    simulateSettleAuction(account?: Address | Account): Promise<{
        request: unknown;
        gasEstimate: bigint;
    }>;
    settleAuction(options?: {
        gas?: bigint;
    }): Promise<Hash>;
    estimateClaimIncentivesGas(positionId: bigint, account?: Address | Account): Promise<bigint>;
    simulateClaimIncentives(positionId: bigint, account?: Address | Account): Promise<{
        request: unknown;
        gasEstimate: bigint;
    }>;
    claimIncentives(positionId: bigint, options?: {
        gas?: bigint;
    }): Promise<Hash>;
    claimIncentivesByPositionKey(args: {
        owner: Address;
        tickLower: number;
        tickUpper: number;
        salt: Hash;
    }): Promise<Hash>;
    watchAuctionSettled(options: OpeningAuctionWatchSettlementOptions): () => void;
}

declare class OpeningAuctionLifecycle {
    private publicClient;
    private walletClient?;
    private initializerAddress;
    private get rpc();
    constructor(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, initializerAddress: Address);
    getAddress(): Address;
    getState(asset: Address): Promise<OpeningAuctionState>;
    getOpeningAuctionHook(asset: Address): Promise<Address>;
    getDopplerHook(asset: Address): Promise<Address>;
    getPositionManager(): Promise<Address>;
    simulateCompleteAuction(asset: Address, dopplerSalt: `0x${string}`, account?: Address | Account): Promise<{
        request: unknown;
    }>;
    completeAuction(asset: Address, dopplerSalt: `0x${string}`): Promise<Hash>;
    simulateRecoverOpeningAuctionIncentives(asset: Address, account?: Address | Account): Promise<{
        request: unknown;
    }>;
    recoverOpeningAuctionIncentives(asset: Address): Promise<Hash>;
    simulateSweepOpeningAuctionIncentives(asset: Address, account?: Address | Account): Promise<{
        request: unknown;
    }>;
    sweepOpeningAuctionIncentives(asset: Address): Promise<Hash>;
}

interface OpeningAuctionModifyLiquidityParams {
    tickLower: number;
    tickUpper: number;
    liquidityDelta: bigint;
    salt: Hash;
}
interface OpeningAuctionModifyLiquiditySimulationResult {
    request: unknown;
    gasEstimate: bigint;
    delta: bigint;
    decoded: {
        amount0: bigint;
        amount1: bigint;
    };
}
interface OpeningAuctionWithdrawFullBidSimulationResult {
    positionId: bigint;
    liquidity: bigint;
    simulation: OpeningAuctionModifyLiquiditySimulationResult;
}
interface OpeningAuctionWithdrawFullBidResult {
    positionId: bigint;
    liquidity: bigint;
    transactionHash: Hash;
}
/**
 * Minimal wrapper around the onchain OpeningAuctionPositionManager.
 *
 * This contract is the intended entrypoint for users to add/remove liquidity
 * during the OpeningAuction, enforcing that the owner encoded in `hookData`
 * matches `msg.sender` to prevent unauthorized removals.
 */
declare class OpeningAuctionPositionManager {
    private publicClient;
    private walletClient?;
    private positionManagerAddress;
    private get rpc();
    constructor(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, positionManagerAddress: Address);
    getAddress(): Address;
    getPoolManager(): Promise<Address>;
    static encodeOwnerHookData(owner: Address, format?: 'packed' | 'abi'): Hex;
    static decodeDelta(delta: bigint): {
        amount0: bigint;
        amount1: bigint;
    };
    static computePositionKey(args: {
        owner: Address;
        tickLower: number;
        tickUpper: number;
        salt: Hash;
    }): Hash;
    static buildSingleTickParams(args: {
        key: V4PoolKey;
        tickLower: number;
        liquidityDelta: bigint;
        salt?: Hash;
    }): OpeningAuctionModifyLiquidityParams;
    static validateSingleTick(args: {
        key: V4PoolKey;
        tickLower: number;
        tickUpper?: number;
    }): {
        tickLower: number;
        tickUpper: number;
    };
    private static assertPositiveLiquidity;
    private estimateModifyLiquidityGas;
    simulateModifyLiquidity(key: V4PoolKey, params: OpeningAuctionModifyLiquidityParams, account?: Address | Account): Promise<OpeningAuctionModifyLiquiditySimulationResult>;
    estimateModifyLiquidityGasWithoutHookData(key: V4PoolKey, params: OpeningAuctionModifyLiquidityParams, account?: Address | Account): Promise<bigint>;
    estimateModifyLiquidityGasWithHookData(key: V4PoolKey, params: OpeningAuctionModifyLiquidityParams, hookData: Hex, account?: Address | Account): Promise<bigint>;
    modifyLiquidity(key: V4PoolKey, params: OpeningAuctionModifyLiquidityParams): Promise<Hash>;
    simulateModifyLiquidityWithHookData(key: V4PoolKey, params: OpeningAuctionModifyLiquidityParams, hookData: Hex, account?: Address | Account): Promise<OpeningAuctionModifyLiquiditySimulationResult>;
    modifyLiquidityWithHookData(key: V4PoolKey, params: OpeningAuctionModifyLiquidityParams, hookData: Hex): Promise<Hash>;
    simulatePlaceBid(args: {
        key: V4PoolKey;
        tickLower: number;
        liquidity: bigint;
        salt?: Hash;
        hookData?: Hex;
        account?: Address | Account;
    }): Promise<OpeningAuctionModifyLiquiditySimulationResult>;
    estimatePlaceBidGas(args: {
        key: V4PoolKey;
        tickLower: number;
        liquidity: bigint;
        salt?: Hash;
        hookData?: Hex;
        account?: Address | Account;
    }): Promise<bigint>;
    placeBid(args: {
        key: V4PoolKey;
        tickLower: number;
        liquidity: bigint;
        salt?: Hash;
        hookData?: Hex;
    }): Promise<Hash>;
    simulateWithdrawBid(args: {
        key: V4PoolKey;
        tickLower: number;
        liquidity: bigint;
        salt?: Hash;
        hookData?: Hex;
        account?: Address | Account;
    }): Promise<OpeningAuctionModifyLiquiditySimulationResult>;
    estimateWithdrawBidGas(args: {
        key: V4PoolKey;
        tickLower: number;
        liquidity: bigint;
        salt?: Hash;
        hookData?: Hex;
        account?: Address | Account;
    }): Promise<bigint>;
    withdrawBid(args: {
        key: V4PoolKey;
        tickLower: number;
        liquidity: bigint;
        salt?: Hash;
        hookData?: Hex;
    }): Promise<Hash>;
    simulateWithdrawFullBid(args: {
        openingAuctionHookAddress: Address;
        key: V4PoolKey;
        tickLower: number;
        salt?: Hash;
        hookData?: Hex;
        owner?: Address;
        account?: Address | Account;
    }): Promise<OpeningAuctionWithdrawFullBidSimulationResult>;
    withdrawFullBid(args: {
        openingAuctionHookAddress: Address;
        key: V4PoolKey;
        tickLower: number;
        salt?: Hash;
        hookData?: Hex;
        owner?: Address;
    }): Promise<OpeningAuctionWithdrawFullBidResult>;
}

interface OpeningAuctionBidManagerConfig {
    openingAuctionHookAddress: Address;
    openingAuctionPoolKey: V4PoolKey;
    positionManagerAddress: Address;
}
interface OpeningAuctionBidArgs {
    tickLower: number;
    liquidity: bigint;
    salt?: Hash;
    owner?: Address;
    hookData?: Hex;
    account?: Address | Account;
}
interface OpeningAuctionWithdrawFullBidArgs {
    tickLower: number;
    salt?: Hash;
    owner?: Address;
    hookData?: Hex;
    account?: Address | Account;
}
interface OpeningAuctionBidLookupArgs {
    tickLower: number;
    salt?: Hash;
    owner?: Address;
    account?: Address | Account;
}
interface OpeningAuctionBidSimulationResult extends OpeningAuctionModifyLiquiditySimulationResult {
    tickLower: number;
    tickUpper: number;
    salt: Hash;
}
interface OpeningAuctionClaimIncentivesSimulationResult {
    positionId: bigint;
    request: unknown;
    gasEstimate: bigint;
}
interface OpeningAuctionBidPositionInfo {
    owner: Address;
    tickLower: number;
    tickUpper: number;
    salt: Hash;
    positionKey: Hash;
    positionId: bigint;
    position: OpeningAuctionPosition;
    isInRange: boolean;
    claimableIncentives: bigint;
}
interface OpeningAuctionBidStatus {
    exists: boolean;
    owner: Address;
    tickLower: number;
    tickUpper: number;
    salt: Hash;
    positionKey: Hash;
    positionId: bigint;
    liquidity: bigint;
    isInRange: boolean;
    claimableIncentives: bigint;
    hasClaimedIncentives: boolean;
    phase: number;
    estimatedClearingTick: number;
    wouldBeFilledAtEstimatedClearing: boolean;
    isAboveEstimatedClearing: boolean;
}
interface OpeningAuctionWatchBidStatusOptions extends OpeningAuctionBidLookupArgs {
    emitOnBegin?: boolean;
    poll?: boolean;
    pollingInterval?: number;
    onError?: (error: Error) => void;
    onStatusChange: (status: OpeningAuctionBidStatus, previousStatus: OpeningAuctionBidStatus | null) => void;
}
interface OpeningAuctionOwnerBidInfo {
    positionId: bigint;
    owner: Address;
    tickLower: number;
    tickUpper: number;
    liquidity: bigint;
    rewardDebtX128: bigint;
    hasClaimedIncentives: boolean;
    isInRange: boolean;
    claimableIncentives: bigint;
}
interface OpeningAuctionOwnerBidStatus extends OpeningAuctionOwnerBidInfo {
    phase: number;
    estimatedClearingTick: number;
    wouldBeFilledAtEstimatedClearing: boolean;
    isAboveEstimatedClearing: boolean;
}
interface OpeningAuctionBidPlacedEvent {
    positionId: bigint;
    owner: Address;
    tickLower: number;
    liquidity: bigint;
    transactionHash: Hash;
    blockNumber: bigint;
    logIndex: number;
}
interface OpeningAuctionBidWithdrawnEvent {
    positionId: bigint;
    transactionHash: Hash;
    blockNumber: bigint;
    logIndex: number;
}
interface OpeningAuctionIncentivesClaimedEvent {
    positionId: bigint;
    owner: Address;
    amount: bigint;
    transactionHash: Hash;
    blockNumber: bigint;
    logIndex: number;
}
interface OpeningAuctionPhaseChangedEvent {
    oldPhase: number;
    newPhase: number;
    transactionHash: Hash;
    blockNumber: bigint;
    logIndex: number;
}
interface OpeningAuctionEstimatedClearingTickUpdatedEvent {
    newEstimatedClearingTick: number;
    transactionHash: Hash;
    blockNumber: bigint;
    logIndex: number;
}
interface OpeningAuctionWatchBidPlacedOptions {
    owner?: Address;
    fromBlock?: bigint;
    poll?: boolean;
    pollingInterval?: number;
    strict?: boolean;
    onError?: (error: Error) => void;
    onBidPlaced: (event: OpeningAuctionBidPlacedEvent) => void;
}
interface OpeningAuctionWatchBidWithdrawnOptions {
    positionId?: bigint;
    fromBlock?: bigint;
    poll?: boolean;
    pollingInterval?: number;
    strict?: boolean;
    onError?: (error: Error) => void;
    onBidWithdrawn: (event: OpeningAuctionBidWithdrawnEvent) => void;
}
interface OpeningAuctionWatchIncentivesClaimedOptions {
    owner?: Address;
    positionId?: bigint;
    fromBlock?: bigint;
    poll?: boolean;
    pollingInterval?: number;
    strict?: boolean;
    onError?: (error: Error) => void;
    onIncentivesClaimed: (event: OpeningAuctionIncentivesClaimedEvent) => void;
}
interface OpeningAuctionWatchPhaseChangeOptions {
    fromBlock?: bigint;
    poll?: boolean;
    pollingInterval?: number;
    strict?: boolean;
    onError?: (error: Error) => void;
    onPhaseChanged: (event: OpeningAuctionPhaseChangedEvent) => void;
}
interface OpeningAuctionWatchEstimatedClearingTickOptions {
    fromBlock?: bigint;
    poll?: boolean;
    pollingInterval?: number;
    strict?: boolean;
    onError?: (error: Error) => void;
    onEstimatedClearingTickUpdated: (event: OpeningAuctionEstimatedClearingTickUpdatedEvent) => void;
}
interface OpeningAuctionMoveBidArgs {
    fromTickLower: number;
    toTickLower: number;
    salt?: Hash;
    owner?: Address;
    account?: Address | Account;
}
interface OpeningAuctionMoveBidSimulationResult {
    withdrawSimulation: OpeningAuctionBidSimulationResult;
    placeSimulation: OpeningAuctionBidSimulationResult;
    liquidity: bigint;
}
interface OpeningAuctionMoveBidResult {
    withdrawTxHash: Hash;
    placeTxHash: Hash;
    liquidity: bigint;
}
interface OpeningAuctionBidQuote {
    tickLower: number;
    tickUpper: number;
    liquidity: bigint;
    amount0Delta: bigint;
    amount1Delta: bigint;
    tokenInAmount0: bigint;
    tokenInAmount1: bigint;
    estimatedClearingTick: number;
    wouldBeFilledAtEstimatedClearing: boolean;
    isAboveEstimatedClearing: boolean;
    estimatedIncentiveShareBps: number | null;
}
interface OpeningAuctionClaimAllIncentivesPreview {
    claimablePositions: Array<{
        positionId: bigint;
        claimableIncentives: bigint;
    }>;
    totalClaimable: bigint;
    skippedPositions: Array<{
        positionId: bigint;
        reason: string;
    }>;
}
interface OpeningAuctionClaimAllIncentivesResult {
    results: Array<{
        positionId: bigint;
        transactionHash?: Hash;
        error?: string;
    }>;
    totalClaimed: number;
    totalFailed: number;
}
interface OpeningAuctionBidValidationResult {
    valid: boolean;
    errors: string[];
    warnings: string[];
    resolved: {
        owner: Address;
        tickLower: number;
        tickUpper: number;
        salt: Hash;
    };
    constraints: {
        minLiquidity: bigint;
        minAcceptableTickToken0: number;
        minAcceptableTickToken1: number;
        phase: number;
        estimatedClearingTick: number;
        isToken0: boolean;
    };
}
interface OpeningAuctionQuoteFromTokenAmountArgs {
    tickLower: number;
    tokenAmount: bigint;
    tokenIndex: 0 | 1;
    salt?: Hash;
    owner?: Address;
    account?: Address | Account;
}
interface OpeningAuctionQuoteFromTokenAmountResult extends OpeningAuctionBidQuote {
    tokenAmount: bigint;
    tokenIndex: 0 | 1;
}
declare class OpeningAuctionBidManager {
    private publicClient;
    private walletClient?;
    private openingAuction;
    private positionManager;
    private openingAuctionPoolKey;
    private openingAuctionHookAddress;
    private _snapshotCache;
    private get rpc();
    constructor(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, config: OpeningAuctionBidManagerConfig);
    /**
     * Construct an OpeningAuctionBidManager from just the hook address.
     * Reads `poolKey` and `positionManager` from the hook contract.
     */
    static fromHookAddress(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, openingAuctionHookAddress: Address): Promise<OpeningAuctionBidManager>;
    getOpeningAuctionHookAddress(): Address;
    getPositionManagerAddress(): Address;
    getPoolKey(): V4PoolKey;
    /**
     * Preflight validation for a bid. Checks tick alignment, liquidity minimums,
     * tick acceptability, and phase gating. Returns actionable errors/warnings.
     */
    validateBid(args: OpeningAuctionBidArgs): Promise<OpeningAuctionBidValidationResult>;
    /**
     * Reverse-quote: given a token amount, derive liquidity and return an enriched quote.
     * The token amount must be specified on the auction token side
     * (`tokenIndex` must match `openingAuction.isToken0()`).
     */
    quoteFromTokenAmount(args: OpeningAuctionQuoteFromTokenAmountArgs): Promise<OpeningAuctionQuoteFromTokenAmountResult>;
    estimatePlaceBidGas(args: OpeningAuctionBidArgs): Promise<bigint>;
    simulatePlaceBid(args: OpeningAuctionBidArgs): Promise<OpeningAuctionBidSimulationResult>;
    placeBid(args: Omit<OpeningAuctionBidArgs, 'account'>, options?: {
        gas?: bigint;
    }): Promise<Hash>;
    estimateWithdrawBidGas(args: OpeningAuctionBidArgs): Promise<bigint>;
    simulateWithdrawBid(args: OpeningAuctionBidArgs): Promise<OpeningAuctionBidSimulationResult>;
    withdrawBid(args: Omit<OpeningAuctionBidArgs, 'account'>, options?: {
        gas?: bigint;
    }): Promise<Hash>;
    simulateWithdrawFullBid(args: OpeningAuctionWithdrawFullBidArgs): Promise<OpeningAuctionWithdrawFullBidSimulationResult>;
    withdrawFullBid(args: Omit<OpeningAuctionWithdrawFullBidArgs, 'account'>, options?: {
        gas?: bigint;
    }): Promise<OpeningAuctionWithdrawFullBidResult>;
    getPositionInfo(args: OpeningAuctionBidLookupArgs): Promise<OpeningAuctionBidPositionInfo | null>;
    getBidStatus(args: OpeningAuctionBidLookupArgs): Promise<OpeningAuctionBidStatus>;
    /**
     * Enumerate all bids for a given owner with enriched info.
     */
    getOwnerBids(args?: {
        owner?: Address;
        account?: Address | Account;
    }): Promise<OpeningAuctionOwnerBidInfo[]>;
    /**
     * Batch fetch position info for multiple position IDs.
     */
    getMultiplePositionInfos(positionIds: bigint[]): Promise<OpeningAuctionOwnerBidInfo[]>;
    /**
     * Batch status for all owner positions including clearing tick info.
     */
    getOwnerBidStatuses(args?: {
        owner?: Address;
        account?: Address | Account;
    }): Promise<OpeningAuctionOwnerBidStatus[]>;
    /**
     * Read liquidity across a tick range.
     */
    getTickLiquidityDistribution(args: {
        startTick: number;
        endTick: number;
        step?: number;
    }): Promise<Array<{
        tick: number;
        liquidity: bigint;
    }>>;
    estimateClaimIncentivesGas(args: OpeningAuctionBidLookupArgs): Promise<bigint>;
    simulateClaimIncentives(args: OpeningAuctionBidLookupArgs): Promise<OpeningAuctionClaimIncentivesSimulationResult>;
    claimIncentives(args: Omit<OpeningAuctionBidLookupArgs, 'account'>, options?: {
        gas?: bigint;
    }): Promise<Hash>;
    simulateIncreaseBid(args: OpeningAuctionBidArgs): Promise<OpeningAuctionBidSimulationResult>;
    estimateIncreaseBidGas(args: OpeningAuctionBidArgs): Promise<bigint>;
    increaseBid(args: Omit<OpeningAuctionBidArgs, 'account'>, options?: {
        gas?: bigint;
    }): Promise<Hash>;
    simulateDecreaseBid(args: OpeningAuctionBidArgs): Promise<OpeningAuctionBidSimulationResult>;
    estimateDecreaseBidGas(args: OpeningAuctionBidArgs): Promise<bigint>;
    decreaseBid(args: Omit<OpeningAuctionBidArgs, 'account'>, options?: {
        gas?: bigint;
    }): Promise<Hash>;
    /**
     * Simulate both legs of a move (withdraw + place) without executing.
     * Use this to pre-validate before calling `moveBid`. See `moveBid` for
     * non-atomic semantics and partial-completion recovery guidance.
     */
    simulateMoveBid(args: OpeningAuctionMoveBidArgs): Promise<OpeningAuctionMoveBidSimulationResult>;
    /**
     * Move a bid from one tick to another by withdrawing and re-placing.
     *
     * **Non-atomic**: This executes two separate transactions (withdraw then place).
     * If the withdraw succeeds but the place fails (e.g. due to gas, slippage, or
     * auction state change), the bid will be in a withdrawn state with funds returned
     * to the caller. To recover, retry with `placeBid` at the desired tick using the
     * same liquidity amount. Use `simulateMoveBid` first to pre-validate both legs.
     */
    moveBid(args: Omit<OpeningAuctionMoveBidArgs, 'account'>, options?: {
        gasWithdraw?: bigint;
        gasPlace?: bigint;
    }): Promise<OpeningAuctionMoveBidResult>;
    quoteBid(args: OpeningAuctionBidArgs): Promise<OpeningAuctionBidQuote>;
    simulateClaimAllIncentives(args?: {
        owner?: Address;
        account?: Address | Account;
    }): Promise<OpeningAuctionClaimAllIncentivesPreview>;
    claimAllIncentives(args?: {
        owner?: Address;
        account?: Address | Account;
        continueOnError?: boolean;
    }): Promise<OpeningAuctionClaimAllIncentivesResult>;
    estimateSettleAuctionGas(account?: Address | Account): Promise<bigint>;
    simulateSettleAuction(account?: Address | Account): Promise<{
        request: unknown;
        gasEstimate: bigint;
    }>;
    settleAuction(options?: {
        gas?: bigint;
    }): Promise<Hash>;
    watchAuctionSettlement(options: OpeningAuctionWatchSettlementOptions): () => void;
    watchBidStatus(options: OpeningAuctionWatchBidStatusOptions): () => void;
    watchBidPlaced(options: OpeningAuctionWatchBidPlacedOptions): () => void;
    watchBidWithdrawn(options: OpeningAuctionWatchBidWithdrawnOptions): () => void;
    watchIncentivesClaimed(options: OpeningAuctionWatchIncentivesClaimedOptions): () => void;
    watchPhaseChange(options: OpeningAuctionWatchPhaseChangeOptions): () => void;
    watchEstimatedClearingTick(options: OpeningAuctionWatchEstimatedClearingTickOptions): () => void;
    /**
     * Preflight guard: runs validateBid and throws if any errors are found.
     */
    private assertValidBid;
    /**
     * Returns a memoized auction snapshot (phase, isToken0, estimatedClearingTick).
     * Cached per block number to reduce redundant reads within composite operations.
     */
    private getAuctionSnapshot;
    /**
     * Invalidate the memoized snapshot (useful after write operations).
     */
    invalidateSnapshot(): void;
    private resolveBidCoordinates;
    private resolveOwner;
    private resolveOwnerOrUndefined;
    private resolveHookData;
    private accountToAddress;
    private assertPositiveLiquidity;
    private static hasStatusChanged;
}

/**
 * Unified Quoter for getting price quotes across Uniswap V2, V3, and V4
 *
 * This class provides a unified interface for price discovery across all
 * supported Uniswap versions, abstracting away the differences between
 * V2 router, V3 quoter, and V4 quoter contracts.
 */
declare class Quoter {
    private publicClient;
    private chainId;
    private get rpc();
    constructor(publicClient: SupportedPublicClient, chainId: number);
    /**
     * Get a price quote for swapping an exact amount of input tokens on Uniswap V3
     * @param params Parameters for the quote
     * @returns Quote result including output amount and price impact
     */
    quoteExactInputV3(params: {
        tokenIn: Address;
        tokenOut: Address;
        amountIn: bigint;
        fee: number;
        sqrtPriceLimitX96?: bigint;
    }): Promise<{
        amountOut: bigint;
        sqrtPriceX96After: bigint;
        initializedTicksCrossed: number;
        gasEstimate: bigint;
    }>;
    /**
     * Get a price quote for receiving an exact amount of output tokens on Uniswap V3
     * @param params Parameters for the quote
     * @returns Quote result including required input amount
     */
    quoteExactOutputV3(params: {
        tokenIn: Address;
        tokenOut: Address;
        amountOut: bigint;
        fee: number;
        sqrtPriceLimitX96?: bigint;
    }): Promise<{
        amountIn: bigint;
        sqrtPriceX96After: bigint;
        initializedTicksCrossed: number;
        gasEstimate: bigint;
    }>;
    /**
     * Get a price quote for swapping an exact amount of input tokens on Uniswap V2
     * @param params Parameters for the quote
     * @returns Array of amounts for each step in the path
     */
    quoteExactInputV2(params: {
        amountIn: bigint;
        path: Address[];
    }): Promise<bigint[]>;
    /**
     * Get a price quote for receiving an exact amount of output tokens on Uniswap V2
     * @param params Parameters for the quote
     * @returns Array of amounts for each step in the path
     */
    quoteExactOutputV2(params: {
        amountOut: bigint;
        path: Address[];
    }): Promise<bigint[]>;
    /**
     * Get a price quote for swapping an exact amount of input tokens on Uniswap V4
     * @param params Parameters for the quote
     * @returns Quote result for V4 pools
     */
    quoteExactInputV4(params: {
        poolKey: {
            currency0: Address;
            currency1: Address;
            fee: number;
            tickSpacing: number;
            hooks: Address;
        };
        zeroForOne: boolean;
        exactAmount: bigint;
        hookData?: string;
    }): Promise<{
        amountOut: bigint;
        gasEstimate: bigint;
    }>;
    /**
     * Get a price quote for receiving an exact amount of output tokens on Uniswap V4
     * @param params Parameters for the quote
     * @returns Quote result for V4 pools
     */
    quoteExactOutputV4(params: {
        poolKey: {
            currency0: Address;
            currency1: Address;
            fee: number;
            tickSpacing: number;
            hooks: Address;
        };
        zeroForOne: boolean;
        exactAmount: bigint;
        hookData?: string;
    }): Promise<{
        amountIn: bigint;
        gasEstimate: bigint;
    }>;
    /**
     * Quote a single exact-input trade using the Uniswap V4 Quoter (not Lens)
     * @param params Parameters for the quote
     */
    quoteExactInputV4Quoter(params: {
        poolKey: {
            currency0: Address;
            currency1: Address;
            fee: number;
            tickSpacing: number;
            hooks: Address;
        };
        zeroForOne: boolean;
        exactAmount: bigint;
        hookData?: string;
    }): Promise<{
        amountOut: bigint;
        gasEstimate: bigint;
    }>;
    /**
     * Quote a single exact-output trade using the Uniswap V4 Quoter (not Lens)
     * @param params Parameters for the quote
     */
    quoteExactOutputV4Quoter(params: {
        poolKey: {
            currency0: Address;
            currency1: Address;
            fee: number;
            tickSpacing: number;
            hooks: Address;
        };
        zeroForOne: boolean;
        exactAmount: bigint;
        hookData?: string;
    }): Promise<{
        amountIn: bigint;
        gasEstimate: bigint;
    }>;
}

/**
 * A class providing read and write access to a DERC20 token contract.
 * Enables querying standard ERC20 token properties along with custom vesting
 * and minting-related state information.
 */
declare class Derc20 {
    protected publicClient: SupportedPublicClient;
    protected walletClient?: WalletClient;
    protected address: Address;
    protected get rpc(): PublicClient;
    protected static splitSignature(signature: `0x${string}`): {
        v: number;
        r: `0x${string}`;
        s: `0x${string}`;
    };
    constructor(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, address: Address);
    /** Get the human-readable name of the token */
    getName(): Promise<string>;
    /** Get the symbol/ticker of the token */
    getSymbol(): Promise<string>;
    /** Get the number of decimals used for token divisions */
    getDecimals(): Promise<number>;
    /** Get the token URI for the token */
    getTokenURI(): Promise<string>;
    /** Get the current delegate for an account */
    getDelegates(account: Address): Promise<Address>;
    /** Get current voting power for an account */
    getVotes(account: Address): Promise<bigint>;
    /** Get historical voting power at a given timepoint (block) */
    getPastVotes(account: Address, timepoint: bigint): Promise<bigint>;
    /**
     * Get the allowance granted by an owner to a spender
     * @param owner - The address that granted the allowance
     * @param spender - The address that can spend the tokens
     */
    getAllowance(owner: Address, spender: Address): Promise<bigint>;
    /**
     * Get the token balance of a specific account
     * @param account - Address to check balance for
     */
    getBalanceOf(account: Address): Promise<bigint>;
    /** Get the total supply of tokens in circulation */
    getTotalSupply(): Promise<bigint>;
    /** Get the duration (in seconds) of the vesting period */
    getVestingDuration(): Promise<bigint>;
    /** Get the timestamp when vesting begins */
    getVestingStart(): Promise<bigint>;
    /** Get the total amount of tokens allocated for vesting */
    getVestedTotalAmount(): Promise<bigint>;
    /** Get the amount of vested tokens available for a specific address */
    getAvailableVestedAmount(account: Address): Promise<bigint>;
    /** Get the current annual mint rate in tokens per year */
    getYearlyMintRate(): Promise<bigint>;
    /** Get the pool address for the token */
    getPool(): Promise<Address>;
    /** Check if the liquidity pool is unlocked */
    getIsPoolUnlocked(): Promise<boolean>;
    /** Get the timestamp when token minting begins */
    getCurrentYearStart(): Promise<bigint>;
    /** Get the timestamp of the last mint */
    getLastMintTimestamp(): Promise<bigint>;
    /**
     * Get detailed vesting information for a specific account
     * @param account - Address to retrieve vesting data for
     * @returns Object containing totalAmount and releasedAmount
     */
    getVestingData(account: Address): Promise<{
        totalAmount: bigint;
        releasedAmount: bigint;
    }>;
    /**
     * Approve a spender to transfer tokens on behalf of the owner
     * @param spender - Address that will be able to spend the tokens
     * @param value - Amount of tokens to approve
     * @returns Transaction hash
     */
    approve(spender: Address, value: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    /**
     * Delegate governance votes to an address
     */
    delegate(delegatee: Address, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    /**
     * Delegate governance votes using an EIP-712 signature (gasless path)
     * Note: Caller signs typed data; a relayer or the caller submits the tx.
     */
    delegateBySig(delegatee: Address, expiry: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    /**
     * Release all currently available vested tokens to the caller
     */
    release(options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
}

declare class Derc20V2 extends Derc20 {
    getVestingScheduleCount(): Promise<bigint>;
    getVestingSchedule(scheduleId: bigint): Promise<{
        cliffDuration: bigint;
        duration: bigint;
    }>;
    getScheduleIdsOf(beneficiary: Address): Promise<bigint[]>;
    getTotalAllocatedOf(beneficiary: Address): Promise<bigint>;
    getAvailableVestedAmountForSchedule(beneficiary: Address, scheduleId: bigint): Promise<bigint>;
    getVestingDataForSchedule(beneficiary: Address, scheduleId: bigint): Promise<{
        totalAmount: bigint;
        releasedAmount: bigint;
    }>;
    releaseSchedule(scheduleId: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    releaseFor(beneficiary: Address, scheduleId?: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
}

declare class DopplerERC20V1 {
    protected publicClient: SupportedPublicClient;
    protected walletClient?: WalletClient;
    protected address: Address;
    protected get rpc(): PublicClient;
    protected static splitSignature(signature: Hex): {
        v: number;
        r: Hex;
        s: Hex;
    };
    constructor(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, address: Address);
    getName(): Promise<string>;
    getSymbol(): Promise<string>;
    getDecimals(): Promise<number>;
    getTokenURI(): Promise<string>;
    getBalanceOf(account: Address): Promise<bigint>;
    getTotalSupply(): Promise<bigint>;
    getAllowance(owner: Address, spender: Address): Promise<bigint>;
    getNonce(owner: Address): Promise<bigint>;
    getDomainSeparator(): Promise<Hex>;
    getDelegates(account: Address): Promise<Address>;
    getVotes(account: Address): Promise<bigint>;
    getPastVotes(account: Address, timepoint: bigint): Promise<bigint>;
    getVotesTotalSupply(): Promise<bigint>;
    getPastVotesTotalSupply(timepoint: bigint): Promise<bigint>;
    getClock(): Promise<number>;
    getClockMode(): Promise<string>;
    getCheckpointCount(account: Address): Promise<bigint>;
    getCheckpointAt(account: Address, index: bigint): Promise<{
        checkpointClock: number;
        checkpointValue: bigint;
    }>;
    getOwner(): Promise<Address>;
    getOwnershipHandoverExpiresAt(pendingOwner: Address): Promise<bigint>;
    getPool(): Promise<Address>;
    isPoolLocked(): Promise<boolean>;
    getVestingStart(): Promise<bigint>;
    getVestedTotalAmount(): Promise<bigint>;
    getVestingScheduleCount(): Promise<bigint>;
    getVestingSchedule(scheduleId: bigint): Promise<{
        cliffDuration: bigint;
        duration: bigint;
    }>;
    getScheduleIdsOf(beneficiary: Address): Promise<bigint[]>;
    getTotalAllocatedOf(beneficiary: Address): Promise<bigint>;
    getAvailableVestedAmountForSchedule(beneficiary: Address, scheduleId: bigint): Promise<bigint>;
    getAvailableVestedAmount(beneficiary: Address): Promise<bigint>;
    getVestingDataForSchedule(beneficiary: Address, scheduleId: bigint): Promise<{
        totalAmount: bigint;
        releasedAmount: bigint;
    }>;
    getMaxBalanceLimit(): Promise<bigint>;
    getBalanceLimitEnd(): Promise<number>;
    isBalanceLimitActive(): Promise<boolean>;
    getController(): Promise<Address>;
    isExcludedFromBalanceLimit(account: Address): Promise<boolean>;
    approve(spender: Address, value: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    permit(owner: Address, spender: Address, value: bigint, deadline: bigint, signature: Hex, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    permit(owner: Address, spender: Address, value: bigint, deadline: bigint, v: number, r: Hex, s: Hex, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    transfer(to: Address, value: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    transferFrom(from: Address, to: Address, value: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    delegate(delegatee: Address, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    delegateBySig(delegatee: Address, expiry: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    transferOwnership(newOwner: Address, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    renounceOwnership(options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    requestOwnershipHandover(options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    cancelOwnershipHandover(options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    completeOwnershipHandover(pendingOwner: Address, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    lockPool(pool: Address, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    unlockPool(options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    burn(amount: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    release(amount: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    releaseSchedule(scheduleId: bigint, amount: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    releaseFor(beneficiary: Address, amount: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    releaseFor(beneficiary: Address, scheduleId: bigint, amount: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    disableBalanceLimit(options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    updateTokenURI(tokenURI: string, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    private getWalletAccountAddress;
    private signTypedData;
    private write;
}

declare class DopplerDN404 {
    private readonly publicClient;
    private readonly walletClient?;
    private readonly address;
    private get rpc();
    constructor(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, address: Address);
    getAddress(): Address;
    getName(): Promise<string>;
    getSymbol(): Promise<string>;
    getDecimals(): Promise<number>;
    getTotalSupply(): Promise<bigint>;
    getBalanceOf(owner: Address): Promise<bigint>;
    getAllowance(owner: Address, spender: Address): Promise<bigint>;
    getUnit(): Promise<bigint>;
    getBaseURI(): Promise<string>;
    getMirrorERC721(): Promise<Address>;
    getTotalNFTSupply(): Promise<bigint>;
    getSkipNFT(owner: Address): Promise<boolean>;
    getPool(): Promise<Address>;
    getIsPoolUnlocked(): Promise<boolean>;
    approve(spender: Address, amount: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    transfer(to: Address, amount: bigint, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    setSkipNFT(skipNFT: boolean, options?: {
        gas?: bigint;
    }): Promise<`0x${string}`>;
    private getWalletClient;
}

/**
 * A class providing read-only access to Ethereum (ETH) token information and balances.
 *
 * @remarks
 * This class implements a consistent interface with other token implementations (like DERC20)
 * but handles ETH-specific behavior such as:
 * - Hardcoded token metadata (name, symbol, decimals)
 * - Simulating unlimited allowance for ETH transfers
 * - Querying native ETH balances through viem
 */
declare class Eth {
    private publicClient;
    private get rpc();
    /** Static ETH address identifier (zero address) */
    static readonly address: "0x0000000000000000000000000000000000000000";
    constructor(publicClient: SupportedPublicClient);
    /**
     * Get the human-readable name of the token
     * @returns Promise resolving to "Ether" (hardcoded ETH name)
     */
    getName(): Promise<string>;
    /**
     * Get the ticker symbol of the token
     * @returns Promise resolving to "ETH" (hardcoded ETH symbol)
     */
    getSymbol(): Promise<string>;
    /**
     * Get the number of decimal places used by the token
     * @returns Promise resolving to 18 (standard ETH decimals)
     */
    getDecimals(): Promise<number>;
    /**
     * Get the allowance granted to a spender (always returns maximum value)
     * @returns Promise resolving to 2^256 - 1 (simulates unlimited ETH allowance)
     *
     * @remarks
     * ETH doesn't have an allowance mechanism, so this returns max uint256 value
     * to represent unlimited approval in systems expecting ERC20-like interfaces
     */
    getAllowance(): Promise<bigint>;
    /**
     * Get the ETH balance of a specified account
     * @param account - Address of the account to query
     * @returns Promise resolving to the account's ETH balance in wei
     */
    getBalanceOf(account: Address): Promise<bigint>;
}

interface TopUpParams {
    asset: Address;
    numeraire: Address;
    amount: bigint;
}
interface TopUpTransaction {
    to: Address;
    data: Hex;
    value?: bigint;
}
interface TopUpSimulationResult {
    request: Parameters<WalletClient['writeContract']>[0];
}
declare class TopUpDistributor {
    private publicClient;
    private walletClient?;
    private topUpDistributorAddress;
    private get rpc();
    constructor(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, topUpDistributorAddress: Address);
    getAddress(): Address;
    buildTopUpTransaction(params: TopUpParams): TopUpTransaction;
    simulateTopUp(params: TopUpParams, account?: Address | Account): Promise<TopUpSimulationResult>;
    topUp(params: TopUpParams, options?: {
        gas?: bigint;
    }): Promise<Hash>;
}

/**
 * A token position held by Bundler for linear vesting.
 *
 * All timestamps and durations are expressed in seconds. Claims always pay the
 * recorded `recipient`; `permissionlessClaim` only controls who may trigger
 * the claim.
 */
interface BundlerVestingPosition {
    recipient: Address;
    permissionlessClaim: boolean;
    start: bigint;
    cliffDuration: bigint;
    vestingDuration: bigint;
    totalAmount: bigint;
    claimedAmount: bigint;
}
/** Result of simulating a Bundler vesting claim. */
interface BundlerClaimSimulation {
    amount: bigint;
    request: Parameters<WalletClient['writeContract']>[0];
}
/**
 * Client for reading and claiming token positions held by a Bundler contract.
 */
declare class Bundler {
    private publicClient;
    private walletClient?;
    private bundlerAddress;
    constructor(publicClient: SupportedPublicClient, walletClient: WalletClient | undefined, bundlerAddress: Address);
    private get rpc();
    /** Returns the Bundler contract address used by this client. */
    getAddress(): Address;
    /**
     * Reads the vesting position for an asset.
     *
     * @param asset Token whose Bundler position should be read.
     */
    getVesting(asset: Address): Promise<BundlerVestingPosition>;
    /**
     * Returns the amount currently claimable for an asset.
     *
     * @param asset Token whose claimable amount should be read.
     */
    getClaimable(asset: Address): Promise<bigint>;
    /**
     * Simulates a claim and returns both the claimable amount and write request.
     *
     * The caller defaults to the configured wallet account. Pass `account` when
     * using a read-only SDK instance. For restricted positions, the caller must
     * be the recorded recipient.
     *
     * @param asset Token to claim.
     * @param account Account that will trigger the claim.
     */
    simulateClaim(asset: Address, account?: Address | Account): Promise<BundlerClaimSimulation>;
    /**
     * Claims the currently vested amount to the position's recorded recipient.
     *
     * Requires a configured wallet client. Permissionless callers may trigger a
     * claim but cannot redirect its proceeds.
     *
     * @param asset Token to claim.
     * @param options Optional transaction gas override.
     * @returns Submitted transaction hash.
     */
    claim(asset: Address, options?: {
        gas?: bigint;
    }): Promise<Hash>;
}

/** Optional Bundler custody schedule for a builder-configured dev buy. */
type BuilderDevBuyVestingInput = {
    permissionlessClaim?: boolean;
    vestingDuration: bigint;
    cliffDuration?: bigint;
};
/** Builder input for an exact-input multicurve dev buy. */
type BuilderDevBuyInput = {
    exactAmountIn: bigint;
    recipient: Address;
    vesting?: BuilderDevBuyVestingInput;
};
type BuilderVestingScheduleInput = {
    duration?: bigint;
    cliffDuration?: number;
};
type BuilderVestingAllocationInput = {
    recipient: Address;
    amount: bigint;
    schedule: BuilderVestingScheduleInput;
};
type BuilderVestingInput = {
    duration?: bigint;
    cliffDuration?: number;
    recipients?: Address[];
    amounts?: bigint[];
    allocations?: never;
} | {
    duration?: never;
    cliffDuration?: never;
    recipients?: never;
    amounts?: never;
    allocations: BuilderVestingAllocationInput[];
};
/**
 * Common interface shared by all auction builders.
 *
 * Defines the methods that all builders (Static, Dynamic, Multicurve) implement.
 * Useful for documentation and ensuring API consistency across builders.
 *
 * @template C - The chain ID type
 */
interface BaseAuctionBuilder<C extends SupportedChainId> {
    /** The chain ID this builder is configured for */
    readonly chainId: C;
    /**
     * Configure the token to be created.
     * Supports standard ERC20, DopplerERC20V1, or Doppler404 token types.
     */
    tokenConfig(params: TokenConfig): this;
    /**
     * Configure the token sale parameters.
     * @param params.initialSupply - Total token supply to mint
     * @param params.numTokensToSell - Number of tokens allocated for the bonding curve
     * @param params.numeraire - The quote token address (e.g., WETH)
     */
    saleConfig(params: {
        initialSupply: bigint;
        numTokensToSell: bigint;
        numeraire: Address;
    }): this;
    /**
     * Configure token vesting for team/investor allocations.
     * Pass undefined or omit to disable vesting.
     */
    withVesting(params?: BuilderVestingInput): this;
    /**
     * Configure governance for the token.
     * @param params - Use { type: 'default' }, { type: 'noOp' }, { type: 'launchpad', multisig: '0x...' }, or { type: 'custom', ... }
     */
    withGovernance(params: GovernanceOption<C>): this;
    /**
     * Configure post-auction liquidity migration.
     * @param migration - Migration target (uniswapV2, uniswapV4, dopplerHookMigrator, or noOp)
     */
    withMigration(migration: MigrationConfig): this;
    /**
     * Set the user address (token creator/owner).
     * Required for build().
     */
    withUserAddress(address: Address): this;
    /**
     * Set the integrator address for fee attribution.
     * Defaults to zero address if not provided.
     */
    withIntegrator(address?: Address): this;
    /**
     * Override the default gas limit for the create transaction.
     */
    withGasLimit(gas?: bigint): this;
    withTokenFactory(address: Address): this;
    withAirlock(address: Address): this;
    withGovernanceFactory(address: Address): this;
    withV2Migrator(address: Address): this;
    withV2MigratorSplit(address: Address): this;
    withV4Migrator(address: Address): this;
    withV4MigratorSplit(address: Address): this;
    withNoOpMigrator(address: Address): this;
}
type MarketCapPresetOverrides = Partial<Record<MulticurveMarketCapPreset, {
    tickLower?: number;
    tickUpper?: number;
    numPositions?: number;
    shares?: bigint;
}>>;

declare class StaticAuctionBuilder<C extends SupportedChainId> implements BaseAuctionBuilder<C> {
    private token?;
    private sale?;
    private pool?;
    private beneficiaries?;
    private vesting?;
    private governance?;
    private migration?;
    private integrator?;
    private userAddress?;
    private moduleAddresses?;
    private gasLimit?;
    private marketCapConfig?;
    chainId: C;
    constructor(chainId: C);
    static forChain<C extends SupportedChainId>(chainId: C): StaticAuctionBuilder<C>;
    tokenConfig(params: TokenConfig): this;
    saleConfig(params: {
        initialSupply: bigint;
        numTokensToSell: bigint;
        numeraire: Address;
    }): this;
    /**
     * Provide pool ticks directly.
     *
     * Note: Static Auctions use Uniswap V3, which only supports 4 fee tiers:
     * 100 (0.01%), 500 (0.05%), 3000 (0.3%), 10000 (1%).
     * For custom fees, use Dynamic or Multicurve auctions (V4).
     */
    poolByTicks(params: {
        startTick?: number;
        endTick?: number;
        fee?: number;
        numPositions?: number;
        maxShareToBeSold?: bigint;
    }): this;
    /**
     * @deprecated Use withMarketCapRange() instead for more intuitive market cap configuration
     */
    poolByPriceRange(params: {
        priceRange: PriceRange;
        fee?: number;
        numPositions?: number;
        maxShareToBeSold?: bigint;
    }): this;
    /**
     * Configure pool using target market cap range.
     * Converts market cap values (in USD) to Uniswap ticks.
     *
     * @param params - Market cap configuration
     * @returns Builder instance for chaining
     *
     * @example
     * ```ts
     * builder
     *   .saleConfig({ initialSupply, numTokensToSell, numeraire: WETH })
     *   .withMarketCapRange({
     *     marketCap: { start: 100_000, end: 10_000_000 }, // $100k to $10M
     *     numerairePrice: 3000, // ETH = $3000
     *   })
     * ```
     */
    withMarketCapRange(params: StaticAuctionMarketCapConfig): this;
    /**
     * Configure beneficiaries for fee streaming on locked V3 pools.
     *
     * When beneficiaries are provided, the pool enters a "Locked" state where:
     * - Fees are collected and distributed to beneficiaries according to their shares
     * - Liquidity cannot be exited/migrated (pool stays locked permanently)
     * - Anyone can call collectFees() to distribute accumulated fees
     *
     * IMPORTANT:
     * - Shares must sum to exactly WAD (1e18 = 100%)
     * - Protocol owner (Airlock.owner()) must be included with at least 5% shares
     * - Beneficiaries will be automatically sorted by address (ascending)
     * - Use withMigration({ type: 'noOp' }) when using beneficiaries
     *
     * @example
     * ```typescript
     * builder.withBeneficiaries([
     *   { beneficiary: protocolOwner, shares: parseEther('0.05') },  // 5% (minimum required)
     *   { beneficiary: teamWallet, shares: parseEther('0.45') },     // 45%
     *   { beneficiary: daoTreasury, shares: parseEther('0.50') },    // 50%
     * ])
     * ```
     */
    withBeneficiaries(beneficiaries: {
        beneficiary: Address;
        shares: bigint;
    }[]): this;
    withVesting(params?: BuilderVestingInput): this;
    withGovernance(params: GovernanceOption<C>): this;
    withMigration(migration: MigrationConfig): this;
    withUserAddress(address: Address): this;
    withIntegrator(address?: Address): this;
    withGasLimit(gas?: bigint): this;
    private overrideModule;
    withTokenFactory(address: Address): this;
    withAirlock(address: Address): this;
    withV3Initializer(address: Address): this;
    withGovernanceFactory(address: Address): this;
    withV2Migrator(address: Address): this;
    withV2MigratorSplit(address: Address): this;
    withV4Migrator(address: Address): this;
    withV4MigratorSplit(address: Address): this;
    withNoOpMigrator(address: Address): this;
    build(): CreateStaticAuctionParams<C>;
}

declare class DynamicAuctionBuilder<C extends SupportedChainId> implements BaseAuctionBuilder<C> {
    private token?;
    private sale?;
    private auction?;
    private pool?;
    private vesting?;
    private governance?;
    private migration?;
    private integrator?;
    private userAddress?;
    private startTimeOffset?;
    private blockTimestamp?;
    private moduleAddresses?;
    private gasLimit?;
    private marketCapConfig?;
    chainId: C;
    constructor(chainId: C);
    static forChain<C extends SupportedChainId>(chainId: C): DynamicAuctionBuilder<C>;
    tokenConfig(params: TokenConfig): this;
    saleConfig(params: {
        initialSupply: bigint;
        numTokensToSell: bigint;
        numeraire?: Address;
    }): this;
    poolConfig(params: {
        fee: number;
        tickSpacing: number;
    }): this;
    auctionByTicks(params: {
        startTick: number;
        endTick: number;
        minProceeds: bigint;
        maxProceeds: bigint;
        duration?: number;
        epochLength?: number;
        gamma?: number;
        numPdSlugs?: number;
    }): this;
    /**
     * @deprecated Use withMarketCapRange() instead for more intuitive market cap configuration
     */
    auctionByPriceRange(params: {
        priceRange: PriceRange;
        minProceeds: bigint;
        maxProceeds: bigint;
        duration?: number;
        epochLength?: number;
        gamma?: number;
        tickSpacing?: number;
        numPdSlugs?: number;
    }): this;
    /**
     * Configure auction using target market cap range.
     * Converts market cap values (in USD) to Uniswap ticks.
     *
     * V4 pools support custom fees (0-100,000). Standard fee tiers auto-derive
     * tickSpacing; custom fees require explicit tickSpacing (max: 30).
     *
     * @param params - Market cap configuration with auction parameters
     * @returns Builder instance for chaining
     *
     * @example Standard fee tier (auto tickSpacing)
     * ```ts
     * builder
     *   .saleConfig({ initialSupply, numTokensToSell, numeraire: WETH })
     *   .withMarketCapRange({
     *     marketCap: { start: 500_000, min: 50_000 },
     *     numerairePrice: 3000,
     *     minProceeds: parseEther('10'),
     *     maxProceeds: parseEther('1000'),
     *     fee: 10000, // Standard tier, tickSpacing auto = 30
     *   })
     * ```
     *
     * @example Custom fee (requires explicit tickSpacing)
     * ```ts
     * builder
     *   .saleConfig({ initialSupply, numTokensToSell, numeraire: WETH })
     *   .withMarketCapRange({
     *     marketCap: { start: 500_000, min: 50_000 },
     *     numerairePrice: 3000,
     *     minProceeds: parseEther('10'),
     *     maxProceeds: parseEther('1000'),
     *     fee: 2500,      // Custom 0.25% fee
     *     tickSpacing: 10, // Required for custom fees
     *   })
     * ```
     */
    withMarketCapRange(params: DynamicAuctionMarketCapConfig): this;
    withVesting(params?: BuilderVestingInput): this;
    withGovernance(params: GovernanceOption<C>): this;
    withMigration(migration: MigrationConfig): this;
    withUserAddress(address: Address): this;
    withIntegrator(address?: Address): this;
    withGasLimit(gas?: bigint): this;
    withTime(params?: {
        startTimeOffset?: number;
        blockTimestamp?: number;
    }): this;
    private overrideModule;
    withTokenFactory(address: Address): this;
    withAirlock(address: Address): this;
    withV4Initializer(address: Address): this;
    withPoolManager(address: Address): this;
    withDopplerDeployer(address: Address): this;
    withGovernanceFactory(address: Address): this;
    withV2Migrator(address: Address): this;
    withV2MigratorSplit(address: Address): this;
    withV4Migrator(address: Address): this;
    withV4MigratorSplit(address: Address): this;
    withDopplerHookMigrator(address: Address): this;
    withRehypeDopplerHookMigrator(address: Address): this;
    withNoOpMigrator(address: Address): this;
    build(): CreateDynamicAuctionParams<C>;
}

declare class MulticurveBuilder<C extends SupportedChainId> implements BaseAuctionBuilder<C> {
    private token?;
    private sale?;
    private pool?;
    private initializer?;
    private schedule?;
    private dopplerHook?;
    private vesting?;
    private devBuy?;
    private governance?;
    private migration?;
    private integrator?;
    private userAddress?;
    private salt?;
    private moduleAddresses?;
    private gasLimit?;
    private feeDistributionControllerAddress?;
    private numerairePrice?;
    private tokenDecimals?;
    private numeraireDecimals?;
    private curvesConfig?;
    chainId: C;
    constructor(chainId: C);
    static forChain<C extends SupportedChainId>(chainId: C): MulticurveBuilder<C>;
    tokenConfig(params: TokenConfig): this;
    saleConfig(params: {
        initialSupply: bigint;
        numTokensToSell: bigint;
        numeraire: Address;
    }): this;
    poolConfig(params: {
        fee: number;
        tickSpacing: number;
        curves: {
            tickLower: number;
            tickUpper: number;
            numPositions: number;
            shares: bigint;
        }[];
        beneficiaries?: {
            beneficiary: Address;
            shares: bigint;
        }[];
    }): this;
    withMarketCapPresets(params?: {
        fee?: number;
        tickSpacing?: number;
        presets?: MulticurveMarketCapPreset[];
        overrides?: MarketCapPresetOverrides;
        beneficiaries?: {
            beneficiary: Address;
            shares: bigint;
        }[];
    }): this;
    /**
     * Configure multicurve using market cap ranges (no tick math required).
     *
     * This is the recommended way to configure multicurve pools. Simply specify
     * market cap ranges in USD for each curve.
     *
     * Curves can be provided in any order - they will be automatically sorted
     * by market cap (ascending) before validation and processing. Curves must
     * be contiguous or overlapping (no gaps allowed).
     *
     * V4 pools support custom fees (0-100,000). Standard fee tiers auto-derive
     * tickSpacing; custom fees require explicit tickSpacing parameter.
     *
     * @param params - Market cap configuration with curves defined by market cap ranges
     * @returns Builder instance for chaining
     *
     * @example Standard fee tier
     * ```ts
     * builder
     *   .saleConfig({ initialSupply, numTokensToSell, numeraire: WETH })
     *   .withCurves({
     *     numerairePrice: 3000,
     *     curves: [...],
     *     fee: 500, // Standard tier, tickSpacing auto-derived
     *   })
     * ```
     *
     * @example Custom fee
     * ```ts
     * builder
     *   .saleConfig({ initialSupply, numTokensToSell, numeraire: WETH })
     *   .withCurves({
     *     numerairePrice: 3000,
     *     curves: [...],
     *     fee: 2500,      // Custom 0.25% fee
     *     tickSpacing: 10, // Required for custom fees
     *   })
     * ```
     */
    withCurves(params: MulticurveMarketCapCurvesConfig): this;
    /**
     * Sort curves by market cap (start, then end) for deterministic ordering
     */
    private sortCurvesByMarketCap;
    private validateCurveRange;
    private validateCurveContiguity;
    /**
     * Configure a RehypeDopplerHookInitializer for the pool.
     *
     * When configured, the hook will be initialized with the pool and will handle:
     * - Custom swap fees
     * - Fee distribution to beneficiaries, LPs, and buyback destinations
     *
     * IMPORTANT:
     * - The hook address must be whitelisted in the DopplerHookInitializer
     * - Fee distribution percentages must sum to exactly WAD (1e18 = 100%)
     *
     * @example
     * ```typescript
     * builder.withRehypeDopplerHookInitializer({
     *   hookAddress: '0x...',
     *   buybackDestination: '0x...',
     *   startFee: 3000, // 0.3%
     *   endFee: 3000,
     *   durationSeconds: 0,
     *   feeDistributionInfo: {
     *     assetFeesToAssetBuybackWad: parseEther('0.2'),
     *     assetFeesToNumeraireBuybackWad: parseEther('0.2'),
     *     assetFeesToBeneficiaryWad: parseEther('0.3'),
     *     assetFeesToLpWad: parseEther('0.3'),
     *     numeraireFeesToAssetBuybackWad: parseEther('0.2'),
     *     numeraireFeesToNumeraireBuybackWad: parseEther('0.2'),
     *     numeraireFeesToBeneficiaryWad: parseEther('0.3'),
     *     numeraireFeesToLpWad: parseEther('0.3'),
     *   },
     * })
     * ```
     */
    withRehypeDopplerHookInitializer(params: RehypeDopplerHookInitializerConfig): this;
    /** @deprecated Use withRehypeDopplerHookInitializer instead. */
    withRehypeDopplerHook(params: RehypeDopplerHookConfig): this;
    withVesting(params?: BuilderVestingInput): this;
    /**
     * Configures an exact-input purchase executed atomically with market creation.
     *
     * Omit `vesting` for direct delivery to `recipient`; when present, Bundler
     * holds the output and releases it under that schedule. This is independent
     * from `withVesting`, which configures token allocation vesting. Passing
     * `undefined` clears the dev buy.
     */
    withDevBuy(params?: BuilderDevBuyInput): this;
    private parseStartTimeSeconds;
    private assertCanSetInitializer;
    /**
     * Configure decay multicurve initializer settings.
     *
     * The pool's terminal fee is always taken from `poolConfig().fee`.
     * `startFee` must be greater than or equal to that terminal fee.
     * `startTime` is optional and defaults to `0` when omitted.
     */
    withDecay(params?: {
        startTime?: number | bigint | Date;
        startFee: number;
        durationSeconds: number | bigint;
    }): this;
    withSchedule(params?: {
        startTime: number | bigint | Date;
    }): this;
    withGovernance(params: GovernanceOption<C>): this;
    /**
     * Configure the address authorized to update a Rehype pool's fee
     * distribution matrix.
     *
     * This sets the on-chain `buybackDst`, which also receives direct-buyback
     * proceeds and legacy empty-beneficiary fees. Every Rehype initializer
     * requires either this method or `buybackDestination`; they configure the
     * same field and cannot be used together.
     */
    withFeeDistributionController(address: Address): this;
    withMigration(migration: MigrationConfig): this;
    withUserAddress(address: Address): this;
    withIntegrator(address?: Address): this;
    withSalt(salt?: Hex): this;
    withGasLimit(gas?: bigint): this;
    private overrideModule;
    withTokenFactory(address: Address): this;
    withAirlock(address: Address): this;
    withBundler(address: Address): this;
    withV4MulticurveInitializer(address: Address): this;
    withV4ScheduledMulticurveInitializer(address: Address): this;
    withV4DecayMulticurveInitializer(address: Address): this;
    withGovernanceFactory(address: Address): this;
    withV2Migrator(address: Address): this;
    withV2MigratorSplit(address: Address): this;
    withV4Migrator(address: Address): this;
    withV4MigratorSplit(address: Address): this;
    withNoOpMigrator(address: Address): this;
    withDopplerHookInitializer(address: Address): this;
    build(): CreateMulticurveParams<C>;
}

interface OpeningAuctionConfig {
    auctionDuration: number;
    minAcceptableTickToken0: number;
    minAcceptableTickToken1: number;
    incentiveShareBps: number;
    tickSpacing: number;
    fee: number;
    minLiquidity: bigint;
    shareToAuctionBps: number;
}
interface OpeningAuctionDopplerConfig {
    minProceeds: bigint;
    maxProceeds: bigint;
    startTick: number;
    endTick: number;
    epochLength?: number;
    duration?: number;
    gamma?: number;
    numPdSlugs?: number;
    fee?: number;
    tickSpacing?: number;
}
interface ResolvedOpeningAuctionDopplerConfig {
    minProceeds: bigint;
    maxProceeds: bigint;
    startTick: number;
    endTick: number;
    epochLength: number;
    duration: number;
    gamma: number;
    numPdSlugs?: number;
    fee: number;
    tickSpacing: number;
}
type OpeningAuctionModuleAddressOverrides = ModuleAddressOverrides & {
    openingAuctionInitializer?: Address;
    openingAuctionPositionManager?: Address;
};
interface CreateOpeningAuctionParams<C extends SupportedChainId = SupportedChainId> {
    token: TokenConfig;
    sale: {
        initialSupply: bigint;
        numTokensToSell: bigint;
        numeraire: Address;
    };
    openingAuction: OpeningAuctionConfig;
    doppler: ResolvedOpeningAuctionDopplerConfig;
    vesting?: VestingConfig;
    governance: GovernanceOption<C>;
    migration: MigrationConfig;
    integrator?: Address;
    userAddress: Address;
    startTimeOffset?: number;
    startingTime?: number;
    blockTimestamp?: number;
    modules?: OpeningAuctionModuleAddressOverrides;
    gas?: bigint;
}
declare class OpeningAuctionBuilder<C extends SupportedChainId> implements BaseAuctionBuilder<C> {
    private token?;
    private sale?;
    private openingAuction?;
    private doppler?;
    private vesting?;
    private governance?;
    private migration?;
    private integrator?;
    private userAddress?;
    private startTimeOffset?;
    private startingTime?;
    private blockTimestamp?;
    private moduleAddresses?;
    private gasLimit?;
    chainId: C;
    constructor(chainId: C);
    static forChain<C extends SupportedChainId>(chainId: C): OpeningAuctionBuilder<C>;
    tokenConfig(params: TokenConfig): this;
    saleConfig(params: {
        initialSupply: bigint;
        numTokensToSell: bigint;
        numeraire: Address;
    }): this;
    openingAuctionConfig(params: OpeningAuctionConfig): this;
    dopplerConfig(params: OpeningAuctionDopplerConfig): this;
    withVesting(params?: BuilderVestingInput): this;
    withGovernance(params: GovernanceOption<C>): this;
    withMigration(migration: MigrationConfig): this;
    withUserAddress(address: Address): this;
    withIntegrator(address?: Address): this;
    withGasLimit(gas?: bigint): this;
    withTime(params?: {
        startTimeOffset?: number;
        startingTime?: number | bigint | Date;
        blockTimestamp?: number;
    }): this;
    private normalizeTimestamp;
    private overrideModule;
    withTokenFactory(address: Address): this;
    withAirlock(address: Address): this;
    withPoolManager(address: Address): this;
    withDopplerDeployer(address: Address): this;
    withGovernanceFactory(address: Address): this;
    withV2Migrator(address: Address): this;
    withV2MigratorSplit(address: Address): this;
    withV4Migrator(address: Address): this;
    withV4MigratorSplit(address: Address): this;
    withNoOpMigrator(address: Address): this;
    withOpeningAuctionInitializer(address: Address): this;
    withOpeningAuctionPositionManager(address: Address): this;
    private validatePositiveInteger;
    build(): CreateOpeningAuctionParams<C>;
}

declare class DopplerSDK<C extends SupportedChainId = SupportedChainId> {
    private publicClient;
    private walletClient?;
    chainId: C;
    private _factory?;
    private _quoter?;
    private _topUpDistributor?;
    private _bundler?;
    constructor(config: DopplerSDKConfig);
    /**
     * Get the factory instance for creating auctions
     */
    get factory(): DopplerFactory<C>;
    /**
     * Get the quoter instance for price queries
     */
    get quoter(): Quoter;
    /**
     * Get the configured TopUpDistributor instance for split-migrator top-ups.
     */
    get topUpDistributor(): TopUpDistributor;
    /**
     * Get a TopUpDistributor instance using the chain default or an explicit override.
     */
    getTopUpDistributor(topUpDistributorAddress?: Address): TopUpDistributor;
    /**
     * Gets the Bundler client configured for this chain.
     *
     * Throws when the chain has no Bundler deployment. Use `getBundler(address)`
     * for custom deployments.
     */
    get bundler(): Bundler;
    /**
     * Creates a Bundler client using the chain default or an explicit address.
     *
     * Read methods work without a wallet client; claims require one.
     *
     * @param bundlerAddress Optional custom Bundler deployment.
     */
    getBundler(bundlerAddress?: Address): Bundler;
    /**
     * Get a StaticAuction instance for interacting with a static auction pool
     * @param poolAddress The address of the Uniswap V3 pool
     */
    getStaticAuction(poolAddress: Address): Promise<StaticAuction>;
    /**
     * Get a DynamicAuction instance for interacting with a dynamic auction hook
     * @param hookAddress The address of the Uniswap V4 hook
     */
    getDynamicAuction(hookAddress: Address): Promise<DynamicAuction>;
    /**
     * Get a RehypeDopplerHookInitializer instance.
     * @param hookAddress The address of the RehypeDopplerHookInitializer
     */
    getRehypeDopplerHookInitializer(hookAddress: Address): Promise<RehypeDopplerHookInitializer>;
    /** @deprecated Use getRehypeDopplerHookInitializer instead. */
    getRehypeDopplerHook(hookAddress: Address): Promise<RehypeDopplerHook>;
    /**
     * Get a RehypeDopplerHookMigrator instance for interacting with migrator-side rehype hook state.
     * @param hookAddress The address of the RehypeDopplerHookMigrator
     */
    getRehypeDopplerHookMigrator(hookAddress: Address): Promise<RehypeDopplerHookMigrator>;
    /**
     * Get an OpeningAuction instance for interacting with an opening auction hook.
     * @param hookAddress The address of the opening auction hook
     */
    getOpeningAuction(hookAddress: Address): Promise<OpeningAuction>;
    /**
     * Get an OpeningAuctionLifecycle instance for interacting with opening-auction completion flows.
     * @param initializerAddress Optional OpeningAuctionInitializer override address
     */
    getOpeningAuctionLifecycle(initializerAddress?: Address): Promise<OpeningAuctionLifecycle>;
    /**
     * Get an OpeningAuctionPositionManager instance for placing/withdrawing opening-auction bids.
     * @param positionManagerAddress Optional OpeningAuctionPositionManager override address
     */
    getOpeningAuctionPositionManager(positionManagerAddress?: Address): Promise<OpeningAuctionPositionManager>;
    /**
     * Get a context-bound OpeningAuctionBidManager for placing/withdrawing bids, status reads, and incentive claims.
     * @param args.openingAuctionHookAddress Opening auction hook address
     * @param args.openingAuctionPoolKey Opening auction pool key from OpeningAuctionLifecycle.getState(asset)
     * @param args.positionManagerAddress Optional OpeningAuctionPositionManager override
     */
    getOpeningAuctionBidManager(args: {
        openingAuctionHookAddress: Address;
        openingAuctionPoolKey: V4PoolKey;
        positionManagerAddress?: Address;
    }): Promise<OpeningAuctionBidManager>;
    /**
     * Get a MulticurvePool instance for interacting with a V4 multicurve pool
     * @param tokenAddress The address of the token created by the auction (called "asset" in contracts; V4 pools don't have addresses, so the token is used as the lookup key)
     */
    getMulticurvePool(tokenAddress: Address): Promise<MulticurvePool>;
    /**
     * Get a DERC20 token instance for interacting with a token
     * @param tokenAddress The address of the DERC20 token
     */
    getDerc20(tokenAddress: Address): Derc20;
    /**
     * Get a DERC20 V2 token instance for interacting with cliffed / multi-schedule vesting tokens
     * @param tokenAddress The address of the DERC20 V2 token
     */
    getDerc20V2(tokenAddress: Address): Derc20V2;
    /**
     * Get a DopplerERC20V1 token instance for schedule vesting and balance-limit controls.
     * @param tokenAddress The address of the DopplerERC20V1 token
     */
    getDopplerERC20V1(tokenAddress: Address): DopplerERC20V1;
    /**
     * Get a Doppler DN404 token instance for hybrid ERC-20/ERC-721 interaction.
     * @param tokenAddress The address of the Doppler DN404 token
     */
    getDopplerDN404(tokenAddress: Address): DopplerDN404;
    /**
     * Get information about a static auction pool
     * @param poolAddress The address of the pool
     */
    getPoolInfo(poolAddress: Address): Promise<PoolInfo>;
    /**
     * Get information about a dynamic auction hook
     * @param hookAddress The address of the hook
     */
    getHookInfo(hookAddress: Address): Promise<HookInfo>;
    /**
     * Create a new static auction builder
     */
    buildStaticAuction(): StaticAuctionBuilder<C>;
    /**
     * Create a new dynamic auction builder
     */
    buildDynamicAuction(): DynamicAuctionBuilder<C>;
    /**
     * Create a new multicurve (V4 initializer) auction builder
     */
    buildMulticurveAuction(): MulticurveBuilder<C>;
    /**
     * Create a new opening auction builder
     */
    buildOpeningAuction(): OpeningAuctionBuilder<C>;
    /**
     * Get the current chain ID
     */
    getChainId(): C;
    /**
     * Get the underlying clients
     */
    getClients(): {
        publicClient: SupportedPublicClient;
        walletClient?: WalletClient;
    };
    /**
     * Get the airlock owner address for the configured chain
     */
    getAirlockOwner(): Promise<Address>;
    /**
     * Convenience helper for building the airlock beneficiary entry with the default 5% (0.05e18 WAD shares)
     */
    getAirlockBeneficiary(shares?: bigint): Promise<BeneficiaryData>;
}

declare const WAD: bigint;
declare const DEAD_ADDRESS: Address;
declare const ZERO_ADDRESS: Address;
/** Standard fee tiers recognized by both Uniswap V3 and V4 */
declare const FEE_TIERS: {
    readonly LOWEST: 100;
    readonly LOW: 500;
    readonly MEDIUM: 3000;
    readonly HIGH: 10000;
};
/** Valid fee tier values (100, 500, 3000, 10000) */
type FeeTier = (typeof FEE_TIERS)[keyof typeof FEE_TIERS];
/**
 * Standard fee tiers - REQUIRED for V3 (Static Auctions).
 * V4 pools can use custom fees but these are the recommended defaults.
 */
declare const VALID_FEE_TIERS: readonly FeeTier[];
/**
 * V3 fee tiers - These are the ONLY valid fees for Uniswap V3 pools.
 * Static Auctions use V3 and must use one of these tiers.
 */
declare const V3_FEE_TIERS: readonly FeeTier[];
/**
 * Maximum LP fee for V4 pools (from DopplerHookInitializer.sol).
 * V4 pools can use any fee from 0 to this value.
 * @see DopplerHookInitializer.sol line 171: `uint24 constant MAX_LP_FEE = 100_000`
 */
declare const V4_MAX_FEE = 100000;
/**
 * Maximum allowed start fee for decay multicurve schedules.
 * This is intentionally higher than V4_MAX_FEE to support anti-sniping launches.
 * 800_000 = 80%
 */
declare const DECAY_MAX_START_FEE = 800000;
declare const TICK_SPACINGS: {
    readonly 100: 1;
    readonly 500: 10;
    readonly 3000: 60;
    readonly 10000: 200;
};
/**
 * Maximum tick spacing allowed by Doppler.sol for dynamic (Dutch) auctions.
 * @see Doppler.sol line 159: `int24 constant MAX_TICK_SPACING = 30`
 */
declare const DOPPLER_MAX_TICK_SPACING = 30;
declare const SECONDS_PER_DAY = 86400;
declare const SECONDS_PER_YEAR: number;
declare const DEFAULT_EPOCH_LENGTH = 43200;
declare const DEFAULT_AUCTION_DURATION: number;
declare const DEFAULT_LOCK_DURATION: number;
declare const DEFAULT_PD_SLUGS = 5;
declare const DAY_SECONDS = 86400;
declare const DEFAULT_V3_START_TICK = 175000;
declare const DEFAULT_V3_END_TICK = 225000;
declare const DEFAULT_V3_NUM_POSITIONS = 15;
declare const DEFAULT_V3_FEE = 10000;
declare const DEFAULT_V3_INITIAL_VOTING_DELAY = 172800;
declare const DEFAULT_V3_INITIAL_VOTING_PERIOD = 1209600;
declare const DEFAULT_V3_INITIAL_PROPOSAL_THRESHOLD = 0n;
declare const DEFAULT_V3_VESTING_DURATION: bigint;
declare const DEFAULT_V3_INITIAL_SUPPLY: bigint;
declare const DEFAULT_V3_NUM_TOKENS_TO_SELL: bigint;
declare const DEFAULT_V3_YEARLY_MINT_RATE: bigint;
declare const DEFAULT_V3_PRE_MINT: bigint;
declare const DEFAULT_V3_MAX_SHARE_TO_BE_SOLD: bigint;
declare const DEFAULT_V4_INITIAL_VOTING_DELAY = 7200;
declare const DEFAULT_V4_INITIAL_VOTING_PERIOD = 50400;
declare const DEFAULT_V4_INITIAL_PROPOSAL_THRESHOLD = 0n;
declare const DEFAULT_V4_YEARLY_MINT_RATE: bigint;
declare const DEFAULT_OPENING_AUCTION_DURATION = 86400;
declare const DEFAULT_OPENING_AUCTION_MIN_ACCEPTABLE_TICK_TOKEN0 = -34020;
declare const DEFAULT_OPENING_AUCTION_MIN_ACCEPTABLE_TICK_TOKEN1 = -34020;
declare const DEFAULT_OPENING_AUCTION_INCENTIVE_SHARE_BPS = 1000;
declare const DEFAULT_OPENING_AUCTION_FEE = 3000;
declare const DEFAULT_OPENING_AUCTION_MIN_LIQUIDITY: bigint;
declare const DEFAULT_OPENING_AUCTION_SHARE_TO_AUCTION_BPS = 10000;
declare const DEFAULT_OPENING_DOPPLER_DURATION: number;
declare const DEFAULT_OPENING_DOPPLER_EPOCH_LENGTH = 43200;
declare const DEFAULT_OPENING_DOPPLER_NUM_PD_SLUGS = 5;
declare const DEFAULT_OPENING_DOPPLER_FEE: 10000;
declare const DEFAULT_OPENING_DOPPLER_TICK_SPACING = 30;
declare const DEFAULT_MULTICURVE_LOWER_TICKS: readonly [-887200, -222200, -176200];
declare const DEFAULT_MULTICURVE_UPPER_TICKS: readonly [-142200, -116300, -84100];
declare const DEFAULT_MULTICURVE_NUM_POSITIONS: readonly [11, 11, 11];
declare const DEFAULT_MULTICURVE_MAX_SUPPLY_SHARES: readonly [bigint, bigint, bigint];
declare const BASIS_POINTS = 10000;
declare const FLAG_MASK: bigint;
declare const DOPPLER_FLAGS: bigint;
declare const OPENING_AUCTION_FLAGS: bigint;
declare const OPENING_AUCTION_PHASE_NOT_STARTED = 0;
declare const OPENING_AUCTION_PHASE_ACTIVE = 1;
declare const OPENING_AUCTION_PHASE_CLOSED = 2;
declare const OPENING_AUCTION_PHASE_SETTLED = 3;
declare const OPENING_AUCTION_STATUS_UNINITIALIZED = 0;
declare const OPENING_AUCTION_STATUS_ACTIVE = 1;
declare const OPENING_AUCTION_STATUS_DOPPLER_ACTIVE = 2;
declare const OPENING_AUCTION_STATUS_EXITED = 3;
declare const INT24_MIN = -8388608;
declare const INT24_MAX = 8388607;
declare const DYNAMIC_FEE_FLAG = 8388608;
declare const FEE_AMOUNT_MASK = 16777215;

/**
 * Tick math utilities for Uniswap V3/V4 price calculations
 *
 * These utilities help convert between ticks, sqrtPriceX96 values, and human-readable prices
 */
declare const MIN_TICK = -887272;
declare const MAX_TICK = 887272;
declare const MIN_SQRT_RATIO = 4295128739n;
declare const MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
declare const Q96: bigint;
/**
 * Get the sqrt ratio at a given tick
 * @param tick The tick value
 * @returns The sqrt price as a Q64.96 fixed point number
 */
declare function getSqrtRatioAtTick(tick: number): bigint;
/**
 * Get the tick at a given sqrt ratio
 * Based on Uniswap v3 TickMath.sol with corrected BigInt handling
 *
 * @param sqrtRatioX96 The sqrt price as a Q64.96 fixed point number
 * @returns The tick value
 */
declare function getTickAtSqrtRatio(sqrtRatioX96: bigint): number;
/**
 * Convert sqrtPriceX96 to a human-readable price
 * Uses BigInt arithmetic throughout to avoid precision loss with Q96
 *
 * @param sqrtPriceX96 The sqrt price as a Q64.96 fixed point number
 * @param decimals0 Decimals of token0
 * @param decimals1 Decimals of token1
 * @param token0IsBase Whether to return price in terms of token0 (true) or token1 (false)
 * @returns The price as a number
 */
declare function sqrtPriceX96ToPrice(sqrtPriceX96: bigint, decimals0: number, decimals1: number, token0IsBase?: boolean): number;
/**
 * Convert a human-readable price to sqrtPriceX96
 * Uses BigInt arithmetic throughout to avoid precision loss with Q96
 *
 * @param price The price (token1/token0)
 * @param decimals0 Decimals of token0
 * @param decimals1 Decimals of token1
 * @returns The sqrt price as a Q64.96 fixed point number
 */
declare function priceToSqrtPriceX96(price: number, decimals0: number, decimals1: number): bigint;
/**
 * Convert a tick to a human-readable price
 * @param tick The tick value
 * @param decimals0 Decimals of token0
 * @param decimals1 Decimals of token1
 * @param token0IsBase Whether to return price in terms of token0 (true) or token1 (false)
 * @returns The price as a number
 */
declare function tickToPrice(tick: number, decimals0: number, decimals1: number, token0IsBase?: boolean): number;
/**
 * Convert a human-readable price to a tick
 * @param price The price (token1/token0)
 * @param decimals0 Decimals of token0
 * @param decimals1 Decimals of token1
 * @returns The tick value
 */
declare function priceToTick(price: number, decimals0: number, decimals1: number): number;
/**
 * Get the nearest usable tick for a given tick spacing
 * @param tick The desired tick
 * @param tickSpacing The tick spacing of the pool
 * @returns The nearest valid tick
 */
declare function getNearestUsableTick(tick: number, tickSpacing: number): number;

/**
 * Price helper utilities for common token launch scenarios
 */
/**
 * Calculate the tick range for a desired price range
 * @param minPrice Minimum price (ETH per token)
 * @param maxPrice Maximum price (ETH per token)
 * @param tickSpacing The tick spacing of the pool
 * @param wethDecimals Decimals of WETH (usually 18)
 * @param tokenDecimals Decimals of the token (usually 18)
 * @returns Object with startTick and endTick
 */
declare function calculateTickRange(minPrice: number, maxPrice: number, tickSpacing: number, wethDecimals?: number, tokenDecimals?: number): {
    startTick: number;
    endTick: number;
};
/**
 * Calculate the number of tokens to sell based on desired raise
 * @param targetRaiseETH Target amount to raise in ETH
 * @param avgPricePerToken Average expected price per token in ETH
 * @returns Number of tokens to sell (as bigint)
 */
declare function calculateTokensToSell(targetRaiseETH: number, avgPricePerToken: number): bigint;
/**
 * Calculate gamma for dynamic auctions
 * @param startTick Starting tick
 * @param endTick Ending tick
 * @param duration Duration in seconds
 * @param epochLength Epoch length in seconds
 * @returns Gamma value
 */
declare function calculateGamma(startTick: number, endTick: number, duration: number, epochLength: number): number;
/**
 * Estimate the price at a specific epoch in a dynamic auction
 * @param startTick Starting tick
 * @param gamma Tick movement per epoch
 * @param currentEpoch Current epoch number
 * @param tokenDecimals Token decimals
 * @param wethDecimals WETH decimals
 * @param isIncreasing Whether price increases (true) or decreases (false) over time
 * @returns Estimated price in ETH per token
 */
declare function estimatePriceAtEpoch(startTick: number, gamma: number, currentEpoch: number, tokenDecimals?: number, wethDecimals?: number, isIncreasing?: boolean): number;
/**
 * Format a tick value to a human-readable price string
 * @param tick The tick value
 * @param tokenSymbol Symbol of the token
 * @param numeraireSymbol Symbol of the numeraire (e.g., "ETH")
 * @param tokenDecimals Token decimals
 * @param numeraireDecimals Numeraire decimals
 * @returns Formatted price string
 */
declare function formatTickAsPrice(tick: number, tokenSymbol: string, numeraireSymbol: string, tokenDecimals?: number, numeraireDecimals?: number): string;
/**
 * Calculate the market cap at a given price
 * @param totalSupply Total token supply (as bigint)
 * @param pricePerToken Price per token in ETH
 * @param ethPrice Current ETH price in USD (optional)
 * @returns Market cap object with ETH and USD values
 */
declare function calculateMarketCap(totalSupply: bigint, pricePerToken: number, ethPrice?: number): {
    eth: string;
    usd?: string;
};
/**
 * Calculate fully diluted valuation (FDV)
 * @param totalSupply Total token supply including vested tokens (as bigint)
 * @param pricePerToken Price per token in ETH
 * @param ethPrice Current ETH price in USD (optional)
 * @returns FDV object with ETH and USD values
 */
declare function calculateFDV(totalSupply: bigint, pricePerToken: number, ethPrice?: number): {
    eth: string;
    usd?: string;
};
/**
 * Estimate slippage for a trade in a concentrated liquidity pool
 * @param amountIn Amount to trade
 * @param liquidity Current liquidity
 * @param currentTick Current tick
 * @param fee Pool fee (e.g., 3000 for 0.3%)
 * @returns Estimated slippage percentage
 */
declare function estimateSlippage(amountIn: bigint, liquidity: bigint, currentTick: number, fee: number): number;

type TokenVariant = 'standard' | 'standard-v2' | 'dopplerERC20V1' | 'doppler404';
interface TokenAddressHookConfig {
    deployer: Address;
    initCodeHash: Hash;
    prefix?: string;
    suffix?: string;
}
interface TokenAddressMiningParams {
    /**
     * Vanity prefix (hex). Keep as `''` (empty string) if you only want to mine a suffix.
     * Note: this is required for backwards compatibility with older SDK versions.
     */
    prefix: string;
    /** Vanity suffix (hex), useful as an identifier at the end of the address. */
    suffix?: string;
    tokenFactory: Address;
    initialSupply: bigint;
    recipient: Address;
    owner: Address;
    tokenData: Hex;
    tokenVariant?: TokenVariant;
    customBytecode?: Hex;
    /**
     * Implementation address for token templates deployed as Solady clones.
     * Used by `standard-v2` and `dopplerERC20V1`.
     */
    v2Implementation?: Address;
    maxIterations?: number;
    startSalt?: bigint;
    hook?: TokenAddressHookConfig;
}
interface TokenAddressMiningResult {
    salt: Hash;
    tokenAddress: Address;
    iterations: number;
    hookAddress?: Address;
}
declare function mineTokenAddress(params: TokenAddressMiningParams): TokenAddressMiningResult;

declare const getAirlockOwner: (publicClient: unknown) => Promise<Address>;
declare const DEFAULT_AIRLOCK_BENEFICIARY_SHARES: bigint;
declare const createAirlockBeneficiary: (owner: Address, shares?: bigint) => BeneficiaryData;
declare const getAirlockBeneficiary: (publicClient: unknown, shares?: bigint) => Promise<BeneficiaryData>;

/**
 * Decode a Uniswap V4 BalanceDelta (int256) value into separate int128 deltas.
 * The upper 128 bits represent amount0, the lower 128 bits represent amount1.
 */
declare function decodeBalanceDelta(delta: bigint): {
    amount0: bigint;
    amount1: bigint;
};

/**
 * Computes the PoolId (bytes32) from a V4 PoolKey
 *
 * In Uniswap V4, a PoolId is computed as keccak256(abi.encode(poolKey))
 * where poolKey contains: currency0, currency1, fee, tickSpacing, hooks
 *
 * @param poolKey - The V4 pool key containing currency0, currency1, fee, tickSpacing, and hooks
 * @returns The computed PoolId as a bytes32 hex string
 */
declare function computePoolId(poolKey: V4PoolKey): Hex;
/**
 * Normalizes a pool key value from various response shapes (tuple array or named fields)
 * into a canonical V4PoolKey object.
 *
 * This handles the different formats that contract reads may return:
 * - Named tuple: { currency0, currency1, fee, tickSpacing, hooks }
 * - Positional array: [currency0, currency1, fee, tickSpacing, hooks]
 */
declare function normalizePoolKey(value: unknown): V4PoolKey;

/**
 * Compute the amount of token0 for a given liquidity and sqrt price range.
 * Mirrors Uniswap V3 SqrtPriceMath.getAmount0Delta (unsigned).
 *
 * amount0 = liquidity * (1/sqrtRatioA - 1/sqrtRatioB)
 *         = liquidity * (sqrtRatioB - sqrtRatioA) / (sqrtRatioA * sqrtRatioB) * Q96
 */
declare function getAmount0ForLiquidity(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): bigint;
/**
 * Compute the amount of token1 for a given liquidity and sqrt price range.
 * Mirrors Uniswap V3 SqrtPriceMath.getAmount1Delta (unsigned).
 *
 * amount1 = liquidity * (sqrtRatioB - sqrtRatioA) / Q96
 */
declare function getAmount1ForLiquidity(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): bigint;
/**
 * Compute the maximum liquidity for a given amount of token0 and sqrt price range.
 * Inverse of getAmount0ForLiquidity.
 *
 * liquidity = amount0 * sqrtRatioA * sqrtRatioB / (Q96 * (sqrtRatioB - sqrtRatioA))
 */
declare function getLiquidityForAmount0(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, amount0: bigint): bigint;
/**
 * Compute the maximum liquidity for a given amount of token1 and sqrt price range.
 * Inverse of getAmount1ForLiquidity.
 *
 * liquidity = amount1 * Q96 / (sqrtRatioB - sqrtRatioA)
 */
declare function getLiquidityForAmount1(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, amount1: bigint): bigint;

type MulticurveMaxTickLiquidityParams = {
    readonly tickLower: number;
    readonly tickUpper: number;
    readonly tickSpacing: number;
    readonly numPositions: number;
    readonly curveSupply: bigint;
};
/**
 * Return the highest upper tick at or below params.tickUpper that can be used
 * by the multicurve initializer without overflowing maxLiquidityPerTick.
 *
 * The public builders use this for "max" market-cap ranges and for factory
 * fallback curves. The candidate tick is stepped down on the tick grid because
 * the safety check depends on the exact generated position boundaries and on
 * cumulative liquidity at each boundary tick.
 */
declare function getMaxLiquiditySafeMulticurveTickUpper(params: MulticurveMaxTickLiquidityParams): number;

/**
 * Compute optimal gamma parameter based on price range and time parameters
 * Gamma determines how much the price can move per epoch during the sale.
 */
declare function computeOptimalGamma(startTick: number, endTick: number, duration: number, epochLength: number, tickSpacing: number): number;

/**
 * Extract the gas estimate from a simulated contract request.
 * Falls back to `estimateContractGas` when the simulation doesn't include a gas value.
 *
 * @param request  The request object returned by `simulateContract`
 * @param fallback A function returning a gas estimate (called only when request.gas is unavailable)
 */
declare function resolveGasEstimate(request: unknown, fallback: () => Promise<bigint>): Promise<bigint>;

/**
 * Determine token ordering based on numeraire address.
 * Mining will find a salt such that token address is correctly ordered relative to numeraire.
 * For numeraires > halfMaxUint160, token must be token0 (smaller address)
 * For all other cases, token should be token1 (larger address)
 * @param numeraire - Address of numeraire token
 * @returns Whether base token address is expected to be generated as token0
 */
declare function isToken0Expected(numeraire: Address): boolean;

/**
 * Sort beneficiaries by address (ascending) as required by the pool contract,
 * rejecting duplicate addresses up-front.
 *
 * The pool/migrator contracts enforce strictly ascending beneficiary addresses
 * and revert with `UnorderedBeneficiaries()` when two entries share an address.
 * Two equal addresses are not strictly ascending, so the transaction reverts and
 * the integrator only finds out after spending gas, with an opaque error.
 *
 * Catching the duplicate here — at the encode layer that every create/migration
 * path funnels through — surfaces a readable error before the transaction is
 * broadcast. Address comparison is case-insensitive, so the same address supplied
 * with different checksum casing is also caught.
 *
 * Generic over the beneficiary shape so it can be reused across the differently
 * typed beneficiary lists (pool initializer, streamable fees, doppler hook).
 */
declare function sortBeneficiaries<T extends {
    beneficiary: Address;
}>(beneficiaries: readonly T[]): T[];
declare function normalizeBeneficiaries<T extends {
    beneficiary: Address;
    shares: bigint;
}>(beneficiaries: readonly T[], label: string): [T, ...T[]];

type NormalizedCommonConfig = {
    hookAddress: Address;
    startFee: number;
    endFee: number;
    durationSeconds: number;
    startingTime: number;
    feeDistributionInfo: RehypeFeeDistributionInfo;
    graduationCalldata?: Hex;
    graduationMarketCap?: number;
    numerairePrice?: number;
    farTick?: number;
};
type NormalizedBuybackConfig = NormalizedCommonConfig & {
    buybackDestination: Address;
    feeBeneficiaries?: never;
    feeRoutingMode: RehypeFeeRoutingMode;
};
type NormalizedBeneficiaryConfig = NormalizedCommonConfig & {
    buybackDestination: Address;
    feeBeneficiaries: [BeneficiaryData, ...BeneficiaryData[]];
    feeRoutingMode: RehypeFeeRoutingMode.RouteToBeneficiaryFees;
};
type NormalizedRehypeDopplerHookInitializerConfig = NormalizedBuybackConfig | NormalizedBeneficiaryConfig;
/**
 * Normalize a Rehype configuration after its fee distribution controller has
 * been configured. `buybackDestination` and `controllerOverride` configure the
 * same on-chain `buybackDst` field and cannot be used together.
 */
declare function normalizeRehypeDopplerHookInitializerConfig(config: RehypeDopplerHookInitializerConfig, controllerOverride?: Address): NormalizedRehypeDopplerHookInitializerConfig;

declare function encodeRehypeDopplerHookInitializerData(numeraire: Address, config: NormalizedRehypeDopplerHookInitializerConfig): Hex;

declare function encodeRehypeDopplerHookMigratorCalldata(params: {
    numeraire: Address;
    config: RehypeDopplerHookMigratorConfig;
}): Hex;

interface ParseAirlockCreateReceiptParams {
    receipt: TransactionReceipt;
    expectedAirlock: Address;
}
interface AirlockCreateResult {
    airlock: Address;
    tokenAddress: Address;
    numeraire: Address;
    initializer: Address;
    poolOrHookAddress: Address;
    transactionHash: Hash;
    blockNumber: bigint;
    logIndex: number;
}
type AirlockCreateReceiptErrorCode = 'RECEIPT_FAILED' | 'WRONG_TRANSACTION_TARGET' | 'WRONG_TRANSACTION_SENDER' | 'MISSING_CREATE_EVENT' | 'MULTIPLE_CREATE_EVENTS' | 'TOKEN_MISMATCH' | 'NUMERAIRE_MISMATCH' | 'INITIALIZER_MISMATCH' | 'POOL_OR_HOOK_MISMATCH' | 'TRANSACTION_HASH_MISMATCH' | 'TRANSACTION_INPUT_MISMATCH' | 'TRANSACTION_VALUE_MISMATCH' | 'MISSING_BUNDLED_EVENT' | 'MULTIPLE_BUNDLED_EVENTS' | 'BUNDLED_RECIPIENT_MISMATCH' | 'BUNDLED_INPUT_MISMATCH' | 'BUNDLED_POOL_KEY_MISMATCH' | 'MISSING_VESTING_EVENT' | 'MULTIPLE_VESTING_EVENTS' | 'UNEXPECTED_VESTING_EVENT' | 'VESTING_MISMATCH';
declare class AirlockCreateReceiptError extends Error {
    readonly code: AirlockCreateReceiptErrorCode;
    readonly expected?: string | number;
    readonly actual?: string | number | null;
    constructor(code: AirlockCreateReceiptErrorCode, options?: {
        expected?: string | number;
        actual?: string | number | null;
    });
}
declare function parseAirlockCreateReceipt({ receipt, expectedAirlock, }: ParseAirlockCreateReceiptParams): AirlockCreateResult | null;
interface PreparedMulticurveIdentity<C extends SupportedChainId = SupportedChainId> {
    chainId: C;
    tokenAddress: Address;
    poolOrHookAddress: Address;
    governanceAddress: Address;
    timelockAddress: Address;
    migrationPoolAddress?: Address;
    poolKey: V4PoolKey;
    poolId: Hash;
    tokenIsCurrency0: boolean;
}
interface VerifiedMulticurveDevBuy {
    amountOut: bigint;
}
interface VerifiedMulticurveCreate<C extends SupportedChainId = SupportedChainId> {
    receiptIdentity: AirlockCreateResult;
    preparedIdentity: PreparedMulticurveIdentity<C>;
    devBuy?: VerifiedMulticurveDevBuy;
}
type PreparedCreateTransactionClient = {
    getTransaction(parameters: {
        hash: Hash;
    }): Promise<{
        hash: Hash;
        from: Address;
        to: Address | null;
        input: Hex;
        value: bigint;
    }>;
};
/**
 * Verifies only facts available in a mined receipt: success, sender, target,
 * one matching Airlock Create event, and its emitted deployment identity.
 *
 * This synchronous check does not retrieve or verify the transaction input or
 * value. Prepared-only predictions remain separate from receipt-derived facts.
 */
declare function verifyPreparedCreateReceipt<C extends SupportedChainId>({ prepared, receipt, }: {
    prepared: PreparedMulticurveCreate<C>;
    receipt: TransactionReceipt;
}): VerifiedMulticurveCreate<C>;
/**
 * Performs the receipt checks in {@link verifyPreparedCreateReceipt}, then
 * retrieves the mined transaction. Its hash must match the receipt, while its
 * sender, target, input, and value must match the prepared unsigned transaction.
 *
 * This stronger check requires one additional RPC request. It proves that the
 * prepared protocol call was mined, but does not turn simulation-only
 * predictions into receipt-derived facts.
 */
declare function verifyPreparedCreateExecution<C extends SupportedChainId>({ prepared, receipt, publicClient, }: {
    prepared: PreparedMulticurveCreate<C>;
    receipt: TransactionReceipt;
    publicClient: PreparedCreateTransactionClient;
}): Promise<VerifiedMulticurveCreate<C>>;

/**
 * Market cap conversion utilities for token launches
 *
 * These utilities convert between market cap (USD) and Uniswap ticks
 * following the mathematical relationship:
 *
 *   Market Cap (USD) → Token Price (USD) → Ratio (numeraire/token) → Tick
 *
 * Based on reference implementation: plan/priceMultiCurve.py
 */

declare function getMaxTickRounded(tickSpacing: number): number;
/**
 * Convert market cap to token price
 *
 * @param marketCapUSD - Market capitalization in USD
 * @param tokenSupply - Total token supply (as bigint with decimals, e.g., parseEther('1000000000'))
 * @param tokenDecimals - Token decimals (default: 18)
 * @returns Price of one token in USD
 *
 * @example
 * ```ts
 * // $1M market cap with 1B tokens (18 decimals)
 * const price = marketCapToTokenPrice(1_000_000, parseEther('1000000000'))
 * // Returns: 0.001 (each token is worth $0.001)
 * ```
 */
declare function marketCapToTokenPrice(marketCapUSD: number, tokenSupply: bigint, tokenDecimals?: number): number;
/**
 * Convert token price to price ratio (numeraire per token)
 *
 * @param tokenPriceUSD - Price of one token in USD
 * @param numerairePriceUSD - Price of numeraire (e.g., ETH) in USD
 * @param tokenDecimals - Token decimals (default: 18)
 * @param numeraireDecimals - Numeraire decimals (default: 18)
 * @returns Price ratio adjusted for decimals
 *
 * @example
 * ```ts
 * // Token at $0.001, ETH at $3000, both 18 decimals
 * const ratio = tokenPriceToRatio(0.001, 3000, 18, 18)
 * // Returns: 3,000,000 (3M ETH wei per token wei at this ratio)
 * ```
 */
declare function tokenPriceToRatio(tokenPriceUSD: number, numerairePriceUSD: number, tokenDecimals?: number, numeraireDecimals?: number): number;
/**
 * Convert ratio to tick using Uniswap's formula: tick = log(ratio) / log(1.0001)
 *
 * @param ratio - Price ratio (must be positive)
 * @returns Raw tick value (before spacing adjustment)
 *
 * @example
 * ```ts
 * ratioToTick(1)       // Returns: 0
 * ratioToTick(1.0001)  // Returns: ~1
 * ratioToTick(Math.pow(1.0001, 1000)) // Returns: ~1000
 * ```
 */
declare function ratioToTick(ratio: number): number;
/**
 * Determine if the new token will be token1 in the Uniswap pair
 *
 * Uniswap orders tokens by address (token0 < token1 in hex comparison).
 * This affects how ticks are interpreted for price calculations.
 *
 * @param tokenAddress - Address of the new token
 * @param numeraireAddress - Address of the numeraire (e.g., WETH)
 * @returns true if token will be token1, false if token0
 *
 * @example
 * ```ts
 * isToken1('0xB000...', '0xA000...') // true (B > A)
 * isToken1('0xA000...', '0xB000...') // false (A < B)
 * ```
 */
declare function isToken1(tokenAddress: string, numeraireAddress: string): boolean;
/**
 * Convert market cap range to ticks for V3 Static Auctions.
 *
 * V3 Static auctions ALWAYS use positive ticks with startTick < endTick.
 * This is because CREATE2 mining ensures token address > numeraire (token1).
 *
 * @param params - Configuration object with market cap range and token parameters
 * @returns { startTick, endTick } - positive ticks, startTick < endTick
 *
 * @example
 * ```ts
 * const { startTick, endTick } = marketCapToTicksForStaticAuction({
 *   marketCapRange: { start: 100_000, end: 10_000_000 },
 *   tokenSupply: parseEther('1000000000'),
 *   numerairePriceUSD: 3000,
 *   tickSpacing: 60,
 * })
 * // Returns: { startTick: 120000, endTick: 170000 } (both positive)
 * ```
 */
declare function marketCapToTicksForStaticAuction(params: StaticAuctionTickParams): {
    startTick: number;
    endTick: number;
};
/**
 * Convert market cap range to ticks for V4 Dynamic Auctions (Doppler).
 *
 * Dynamic auctions compute tick sign based on expected token ordering:
 * - Token1 (ETH numeraire): positive ticks, startTick < endTick
 * - Token0 (stablecoin numeraire): negative ticks, startTick > endTick
 *
 * Unlike Multicurve, Doppler contract does NOT auto-flip ticks.
 *
 * @param params - Configuration object with market cap range and token parameters
 * @returns { startTick, endTick } with correct sign and ordering for Doppler contract
 *
 * @example
 * ```ts
 * // ETH numeraire (token1) - positive ticks
 * const eth = marketCapToTicksForDynamicAuction({
 *   marketCapRange: { start: 50_000, end: 500_000 },
 *   tokenSupply: parseEther('1000000000'),
 *   numerairePriceUSD: 3000,
 *   numeraire: WETH_ADDRESS,
 *   tickSpacing: 30,
 * })
 * // Returns: { startTick: 120000, endTick: 170000 } (positive, ascending)
 *
 * // USDC numeraire (token0) - negative ticks
 * const usdc = marketCapToTicksForDynamicAuction({
 *   marketCapRange: { start: 50_000, end: 500_000 },
 *   tokenSupply: parseEther('1000000000'),
 *   numerairePriceUSD: 1,
 *   numeraire: USDC_ADDRESS,
 *   tickSpacing: 30,
 *   tokenDecimals: 18,
 *   numeraireDecimals: 6,
 * })
 * // Returns: { startTick: -120000, endTick: -170000 } (negative, descending)
 * ```
 */
declare function marketCapToTicksForDynamicAuction(params: DynamicAuctionTickParams): {
    startTick: number;
    endTick: number;
};
/**
 * Convert market cap range to ticks for V4 Multicurve pools.
 *
 * Tick sign depends on the underlying price ratio - can be positive or negative.
 * The contract's adjustCurves() handles token ordering internally.
 *
 * @param params - Configuration object with market cap range and token parameters
 * @returns { tickLower, tickUpper } - tick range where tickLower < tickUpper
 *
 * @example
 * ```ts
 * const { tickLower, tickUpper } = marketCapToTicksForMulticurve({
 *   marketCapLower: 500_000,
 *   marketCapUpper: 5_000_000,
 *   tokenSupply: parseEther('1000000000'),
 *   numerairePriceUSD: 3000,
 *   tickSpacing: 60,
 * })
 * ```
 */
declare function marketCapToTicksForMulticurve(params: MulticurveTickRangeParams): {
    tickLower: number;
    tickUpper: number;
};
/**
 * Convert a single market cap to a tick for Multicurve use cases.
 *
 * Used for farTick and pegTick calculations.
 * Tick sign depends on the underlying price ratio - can be positive or negative.
 *
 * @param params - Configuration object with market cap and token parameters
 * @returns Tick value (sign depends on price ratio)
 *
 * @example
 * ```ts
 * const farTick = marketCapToTickForMulticurve({
 *   marketCapUSD: 50_000_000,
 *   tokenSupply: supply,
 *   numerairePriceUSD: 3000,
 *   tickSpacing: 60,
 * })
 * ```
 */
declare function marketCapToTickForMulticurve(params: MulticurveTickParams): number;
/**
 * Apply curvature offsets to a peg tick for Multicurve positions.
 *
 * Tick sign depends on the underlying price ratio - can be positive or negative.
 * The contract's adjustCurves() handles token ordering internally.
 *
 * @example
 * ```ts
 * // Peg at 200000, curve extends 10000 ticks toward higher market cap
 * applyTickOffsets(200000, 0, 10000, WETH)
 * // Returns: { tickLower: 200000, tickUpper: 210000 }
 * ```
 */
declare function applyTickOffsets(pegTick: number, offsetLower: number, offsetUpper: number, numeraire: Address): {
    tickLower: number;
    tickUpper: number;
};
/**
 * Validate market cap parameters and return warnings for unusual values
 *
 * This doesn't prevent execution but helps catch potential mistakes:
 * - Very small market caps (< $1,000)
 * - Very large market caps (> $1 trillion)
 * - Extreme token prices (< $0.000001 or > $1M)
 *
 * @param marketCap - Market cap value to validate
 * @param tokenSupply - Token supply (with decimals)
 * @param tokenDecimals - Token decimals (default: 18)
 * @returns Validation result with warnings array
 *
 * @example
 * ```ts
 * const result = validateMarketCapParameters(500, parseEther('1000000'))
 * if (result.warnings.length > 0) {
 *   console.warn('Warnings:', result.warnings)
 * }
 * ```
 */
declare function validateMarketCapParameters(marketCap: number, tokenSupply: bigint, tokenDecimals?: number): MarketCapValidationResult;
/**
 * Calculate market cap from a tick (reverse conversion)
 *
 * Useful for displaying what market cap a given tick represents.
 * Works with ticks from any auction type (Static, Dynamic, Multicurve).
 *
 * @param params - Configuration object with tick and token parameters
 * @returns Market cap in USD
 *
 * @example
 * ```ts
 * // Works with negative ticks (Multicurve)
 * tickToMarketCap({
 *   tick: -156000,
 *   tokenSupply: supply,
 *   numerairePriceUSD: 3000,
 * })
 *
 * // Works with positive ticks (Static/Dynamic)
 * tickToMarketCap({
 *   tick: 156000,
 *   tokenSupply: supply,
 *   numerairePriceUSD: 3000,
 * })
 * ```
 */
declare function tickToMarketCap(params: TickToMarketCapParams): number;

declare const dopplerDN404Abi: readonly [{
    readonly type: "function";
    readonly name: "name";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "symbol";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "decimals";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "totalSupply";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "balanceOf";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "allowance";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly name: "spender";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "approve";
    readonly inputs: readonly [{
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "transfer";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "unit";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "baseURI";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "mirrorERC721";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "totalNFTSupply";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getSkipNFT";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "setSkipNFT";
    readonly inputs: readonly [{
        readonly name: "skipNFT";
        readonly type: "bool";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "pool";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "isPoolUnlocked";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
}];

declare const feesManagerAbi: readonly [{
    readonly type: "function";
    readonly name: "getCumulatedFees0";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getCumulatedFees1";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getLastCumulatedFees0";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getLastCumulatedFees1";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getShares";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getPoolKey";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "currency0";
        readonly type: "address";
        readonly internalType: "Currency";
    }, {
        readonly name: "currency1";
        readonly type: "address";
        readonly internalType: "Currency";
    }, {
        readonly name: "fee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "tickSpacing";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "hooks";
        readonly type: "address";
        readonly internalType: "contract IHooks";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "updateBeneficiary";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "newBeneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "event";
    readonly name: "Collect";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "fees0";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Release";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "beneficiary";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "fees0";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "UpdateBeneficiary";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: false;
        readonly internalType: "PoolId";
    }, {
        readonly name: "oldBeneficiary";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }, {
        readonly name: "newBeneficiary";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "error";
    readonly name: "CallerNotBeneficiary";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidNewBeneficiary";
    readonly inputs: readonly [];
}];
/** @deprecated Use feesManagerAbi instead. */
declare const feeClaimsInitializerAbi: readonly [{
    readonly type: "function";
    readonly name: "getCumulatedFees0";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getCumulatedFees1";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getLastCumulatedFees0";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getLastCumulatedFees1";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getShares";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getPoolKey";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "currency0";
        readonly type: "address";
        readonly internalType: "Currency";
    }, {
        readonly name: "currency1";
        readonly type: "address";
        readonly internalType: "Currency";
    }, {
        readonly name: "fee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "tickSpacing";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "hooks";
        readonly type: "address";
        readonly internalType: "contract IHooks";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "updateBeneficiary";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "newBeneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "event";
    readonly name: "Collect";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "fees0";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Release";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "beneficiary";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "fees0";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "UpdateBeneficiary";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: false;
        readonly internalType: "PoolId";
    }, {
        readonly name: "oldBeneficiary";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }, {
        readonly name: "newBeneficiary";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "error";
    readonly name: "CallerNotBeneficiary";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidNewBeneficiary";
    readonly inputs: readonly [];
}];

declare const _default$6: "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";

declare const _default$5: "0x60a0604052346104a85761390680380380610019816107f1565b928339810160e0828203126104a85781516001600160401b0381116104a85781610044918401610816565b60208301519091906001600160401b0381116104a85781610066918501610816565b9060408401519161007960608601610867565b9361008660808701610867565b60a08701519093906001600160401b0381116104a85760c0916100aa918901610816565b960151926001600160a01b031680156107de575f80546001600160a01b03198116831782556001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09080a382156107cf578284066107c0578051906001600160401b0382116104eb5760015490600182811c921680156107b6575b60208310146105d05781601f849311610748575b50602090601f83116001146106e2575f926106d7575b50508160011b915f199060031b1c1916176001555b8051906001600160401b0382116104eb5760025490600182811c921680156106cd575b60208310146105d05781601f84931161065f575b50602090601f83116001146105f9575f926105ee575b50508160011b915f199060031b1c1916176002555b83516001600160401b0381116104eb57600354600181811c911680156105e4575b60208210146105d057601f811161056d575b50602094601f821160011461050a579481929394955f926104ff575b50508160011b915f199060031b1c1916176003555b608052604051610d35808201906001600160401b038211838310176104eb576020918391612bd183393381520301905ff080156104e0576080516001600160a01b0391909116906001600160601b035f1990910110156104d35768a20d6e21d0e5255309546001600160a01b03166104c65780156104b957630f4599e55f523360205260205f6024601c82855af160015f511416156104ac57678da5cb5b6cef16e65f5260208060046018305afa601f3d1160205160601b151016610499575b68a20d6e21d0e5255308805463ffffffff60201b191664010000000017905568a20d6e21d0e525530980546001600160a01b03191691909117905580610375575b604051612334908161089d823960805181818161040b01528181610a4f01528181610c1c015281816114860152818161171c015281816119110152611f920152f35b6001600160a01b03821691821561048c57608051820463fffffffe108260601c1761047f5768a20d6e21d0e525530880546001600160a01b031660a084901b6001600160a01b03191690811790915561041292906103d28361087b565b80546001600160a01b031690911790555f90815283907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602082a361087b565b906bff00000000000000000000008254918260581c9060015f527fb5a1de456fff688115a4f75380060c23c8532d14ff85f687cc871456d642039360205fa2600260ff821691161560011b1860011760581b16906bff000000000000000000000019161790555f80610333565b63e5cfe9575f526004601cfd5b63ea553b345f526004601cfd5b5f806004601c82855af16102f2575b5f80fd5b63d125259c5f526004601cfd5b6339a84a7b5f526004601cfd5b63ead4d2e45f526004601cfd5b63997c4ef45f526004601cfd5b6040513d5f823e3d90fd5b634e487b7160e01b5f52604160045260245ffd5b015190505f8061021d565b601f1982169560035f52805f20915f5b8881106105555750836001959697981061053d575b505050811b01600355610232565b01515f1960f88460031b161c191690555f808061052f565b9192602060018192868501518155019401920161051a565b60035f527fc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b601f830160051c810191602084106105c6575b601f0160051c01905b8181106105bb5750610201565b5f81556001016105ae565b90915081906105a5565b634e487b7160e01b5f52602260045260245ffd5b90607f16906101ef565b015190505f806101b9565b60025f9081528281209350601f198516905b818110610647575090846001959493921061062f575b505050811b016002556101ce565b01515f1960f88460031b161c191690555f8080610621565b9293602060018192878601518155019501930161060b565b60025f529091507f405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace601f840160051c810191602085106106c3575b90601f859493920160051c01905b8181106106b557506101a3565b5f81558493506001016106a8565b909150819061069a565b91607f169161018f565b015190505f80610157565b60015f9081528281209350601f198516905b8181106107305750908460019594939210610718575b505050811b0160015561016c565b01515f1960f88460031b161c191690555f808061070a565b929360206001819287860151815501950193016106f4565b60015f529091507fb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6601f840160051c810191602085106107ac575b90601f859493920160051c01905b81811061079e5750610141565b5f8155849350600101610791565b9091508190610783565b91607f169161012d565b633eaf92f760e21b5f5260045ffd5b63265f13bd60e21b5f5260045ffd5b631e4fbdf760e01b5f525f60045260245ffd5b6040519190601f01601f191682016001600160401b038111838210176104eb57604052565b81601f820112156104a8578051906001600160401b0382116104eb57610845601f8301601f19166020016107f1565b92828452602083830101116104a857815f9260208093018386015e8301015290565b51906001600160a01b03821682036104a857565b6001600160a01b03165f90815268a20d6e21d0e5255313602052604090209056fe608080604052600436101561075d575b503615610752575f3560e01c63e5eb36c881146103d25763f6916ddd811461038f576362fb246d811461036b57632d8a746e81146103325763c016aa52811461031f5763d10b6e0c811461022f576327ef549581146102145763f5b100ea81146101ef5763e2c7928181146101d45763cb30b46081146100a95763b7a94eb8146100a057633c10b94e5f526004601cfd5b60015f5260205ff35b60206040510160405260606003546100c0816113a1565b6100e4575b50605f601f198201915f6020825180930101526020835201601f191690f35b905060405190608082019160a081016040525f8352600a600435935b5f19019360308282060185530492831561011c57600a90610100565b9250608083601f19810192030181526040519283915f9061013c856113a1565b94600181169081156101b45750600114610173575b61016d9450518092825e015f815203601f1981018352826113d9565b816100c5565b905060035f5260205f20935f5b818110610198575061016d9450830160200190610151565b8554602082890181019190915260019096019587955001610180565b602092935061016d96915060ff1916828601528015150284010190610151565b63ffffffff68a20d6e21d0e52553085460801c165f5260205ff35b63ffffffff6102086004356001600160a01b031661135f565b5460801c165f5260205ff35b6001600160a01b03610227600435612130565b165f5260205ff35b68a20d6e21d0e5255309546001600160a01b03163303610312576001600160a01b036044358116906024359060043581169061028061027b5f19600160201b861086020160011b612055565b6120eb565b5416928381036102ef575b505f82815268a20d6e21d0e525530c60209081526040822080546001600160a01b0319166001600160a01b03851617905568a20d6e21d0e525530d60601b600885901c018054600160ff90961695861b191693151590941b92909217909255918152f35b6102f990846115cd565b5415610305578361028b565b63cfb3b9425f526004601cfd5b63ce5a776b5f526004601cfd5b6001600160a01b03610227600435612107565b6004356001600160a01b0361034682612107565b161561035e576001600160a01b039061022790612107565b63ceea21b65f526004601cfd5b6103856001600160a01b03602435811690600435166115cd565b5415155f5260205ff35b68a20d6e21d0e5255309546001600160a01b031633036103125760243515156103c86001600160a01b03600435811690604435166115cd565b5560015f5260205ff35b68a20d6e21d0e5255309546001600160a01b031633819003610312576001600160a01b0360043581165f818152600560205260409020547f000000000000000000000000000000000000000000000000000000000000000093919260443592916064358216916024351690610448908790611438565b935f925f948661072d575b83156107205715610713576001600160a01b0361048061027b600160201b851085025f190160011b612055565b54168703610706578681036106cd575b5061049a8661135f565b906104a48361135f565b90825460a01c808a116106c0576105a69361055e916104cf908c90036001600160601b031682612169565b83546104ee9060a01c6001600160601b038d8116919091011685612169565b6104f78361229f565b61068f575b600161052b61050a8c611380565b9261052563ffffffff5f1981845460801c160116809261218c565b83612079565b61054d8161053f5f198801851b8501612055565b9463ffffffff8616906120c3565b63ffffffff165f1901811b01612095565b6105a08463ffffffff845460801c169361058163ffffffff60018701168261218c565b61059b61058d83611380565b8663ffffffff8716916120c3565b6121d0565b90612260565b855f52845f8051602061231483398151915260205fa36105c95760015f5260205ff35b5f19820191821161067b5763ffffffff6105e28461135f565b5460801c169182811061060d575b5050505f52600560205260405f20908154039055808080806100a0565b61061684611380565b928210156105f0578181146105f0576001826106628363ffffffff8481966106628a610645886106739d612079565b928161065d610655838795612079565b809b836120c3565b6120c3565b825f19911601811b01911690612095565b8280806105f0565b634e487b7160e01b5f52601160045260245ffd5b610698836121af565b5f83815268a20d6e21d0e525530c6020526040902080546001600160a01b03191690556104fc565b63f4d678b85f526004601cfd5b6106d781886115cd565b54610490576001600160a01b036106ed83612130565b16036106f95787610490565b6359c896be5f526004601cfd5b63a11481005f526004601cfd5b6340739bf05f526004601cfd5b63ea553b345f526004601cfd5b9350935063ffffffff61074760015f198401811b01612055565b169385851093610453565b3461075957005b5f80fd5b5f3560e01c90816306fdde031461126757508063095ea7b3146111c65780630ad9e7bf1461118e57806310aa0ebb1461116957806316f0115b1461114157806318160ddd14611119578063207d0636146110d657806323b872dd14611030578063274e430b146110035780632a6a935d14610f915780632f745c5914610f2a578063313ce56714610f0f5780634ef41efc14610edf5780634f6ccce714610ec157806355f804b314610d685780635b2aa23914610bcb5780636c0360eb14610b3957806370a0823114610b0a578063715018a614610ac65780638902653814610a995780638da5cb5b14610a72578063907af6c014610a3857806395d89b411461095e578063a9059cbb1461092d578063dd62ed3e146108f95763f2fde38b14610887575f61000f565b34610759576020366003190112610759576108a0611333565b6108a8611589565b6001600160a01b031680156108e6575f80546001600160a01b03198116831782556001600160a01b0316905f805160206122f48339815191529080a3005b631e4fbdf760e01b5f525f60045260245ffd5b34610759576040366003190112610759576020610925610917611333565b61091f611349565b90611523565b604051908152f35b3461075957604036600319011261075957610953610949611333565b60243590336115eb565b602060405160018152f35b34610759575f366003190112610759576040515f60025461097e816113a1565b8084529060018116908115610a1457506001146109b6575b6109b2836109a6818503826113d9565b60405191829182611309565b0390f35b60025f9081527f405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace939250905b8082106109fa575090915081016020016109a6610996565b9192600181602092548385880101520191019092916109e2565b60ff191660208086019190915291151560051b840190910191506109a69050610996565b34610759575f3660031901126107595760206040517f00000000000000000000000000000000000000000000000000000000000000008152f35b34610759575f366003190112610759575f546040516001600160a01b039091168152602090f35b34610759575f36600319011261075957610ab1611589565b6004805460ff60a01b1916600160a01b179055005b34610759575f36600319011261075957610ade611589565b5f80546001600160a01b0319811682556001600160a01b03165f805160206122f48339815191528280a3005b34610759576020366003190112610759576020610b2d610b28611333565b61135f565b5460a01c604051908152f35b34610759575f366003190112610759576040515f600354610b59816113a1565b8084529060018116908115610a145750600114610b80576109b2836109a6818503826113d9565b60035f9081525f805160206122d4833981519152939250905b808210610bb1575090915081016020016109a6610996565b919260018160209254838588010152019101909291610b99565b34610759576020366003190112610759576004356001600160401b03811161075957366023820112156107595760048101356001600160401b038111610759573660248260051b84010111610759577f0000000000000000000000000000000000000000000000000000000000000000918282029282840481148315171561067b57335f52600560205260405f205493610c643361135f565b5460a01c610c728287611456565b11610d5957610c84610c8a9286611438565b94611456565b335f52600560205260405f2055610ca03361135f565b9263ffffffff610caf33611380565b945460801c16915f915b84831015610d575760248360051b8301013584811015610d4857818110610d3e578181600193849303610cf2575b5001925b0191610cb9565b8063ffffffff848b61066282610d0b610d389784612079565b610d26818a610d1a8188612079565b9661065d888c836120c3565b888616919086165f1901811b01612095565b88610ce7565b5091600190610ceb565b633277964160e01b5f5260045ffd5b005b6302579b0560e11b5f5260045ffd5b34610759576020366003190112610759576004356001600160401b03811161075957366023820112156107595760048101356001600160401b03811161075957366024828401011161075957610dbc611589565b610dc76003546113a1565b601f8111610e71575b505f601f8211600114610e0c5781925f92610dfe575b50508160011b915f199060031b1c1916176003555f80f35b602492500101358280610de6565b601f1982169260035f5260205f20915f5b858110610e5657508360019510610e3a575b505050811b01600355005b01602401355f19600384901b60f8161c19169055828080610e2f565b90926020600181926024878701013581550194019101610e1d565b60035f525f805160206122d4833981519152601f830160051c81019160208410610eb7575b601f0160051c01905b818110610eac5750610dd0565b5f8155600101610e9f565b9091508190610e96565b34610759576020366003190112610759576020610925600435611463565b34610759575f3660031901126107595768a20d6e21d0e5255309546040516001600160a01b039091168152602090f35b34610759575f36600319011261075957602060405160128152f35b3461075957604036600319011261075957610f43611333565b60243563ffffffff610f548361135f565b5460801c16811015610f8257610f7963ffffffff91610f74602094611380565b612079565b16604051908152f35b6306ed618760e11b5f5260045ffd5b3461075957602036600319011261075957600435801580158092036107595761095391610fbd3361135f565b91825460581c915f52337fb5a1de456fff688115a4f75380060c23c8532d14ff85f687cc871456d642039360205fa2600260ff83169216151860011b186001179061156c565b34610759576020366003190112610759576020611026611021611333565b611410565b6040519015158152f35b3461075957606036600319011261075957611049611333565b611051611349565b6044359061105f33846115af565b926e22d473030f116ddee9f6b43ac78ba33314806110bf575b156110b7575f19935b60018501611095575b5061095393506115eb565b8484116110aa5783610953950390558461108a565b6313be252b5f526004601cfd5b835493611081565b5060046110cb8261135f565b5460581c1615611078565b34610759576020366003190112610759576110ef611333565b6110f7611589565b600480546001600160a81b0319166001600160a01b0392909216919091179055005b34610759575f36600319011261075957602068a20d6e21d0e52553085460a01c604051908152f35b34610759575f366003190112610759576004546040516001600160a01b039091168152602090f35b34610759575f36600319011261075957602060ff60045460a01c166040519015158152f35b34610759576020366003190112610759576001600160a01b036111af611333565b165f526005602052602060405f2054604051908152f35b34610759576040366003190112610759576111df611333565b6001600160a01b03811690602435908190611211906e22d473030f116ddee9f6b43ac78ba38514611245575b336115af565b555f52337f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560205fa3602060405160018152f35b6112626112513361135f565b600460ff825460581c16179061156c565b61120b565b34610759575f366003190112610759575f600154611284816113a1565b8084529060018116908115610a1457506001146112ab576109b2836109a6818503826113d9565b60015f9081527fb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6939250905b8082106112ef575090915081016020016109a6610996565b9192600181602092548385880101520191019092916112d7565b602060409281835280519182918282860152018484015e5f828201840152601f01601f1916010190565b600435906001600160a01b038216820361075957565b602435906001600160a01b038216820361075957565b6001600160a01b03165f90815268a20d6e21d0e52553136020526040902090565b6001600160a01b03165f90815268a20d6e21d0e52553106020526040902090565b90600182811c921680156113cf575b60208310146113bb57565b634e487b7160e01b5f52602260045260245ffd5b91607f16916113b0565b601f909101601f19168101906001600160401b038211908210176113fc57604052565b634e487b7160e01b5f52604160045260245ffd5b9061141a8261135f565b5460581c9160016002841615159316156114315750565b3b15159150565b8115611442570490565b634e487b7160e01b5f52601260045260245ffd5b9190820180921161067b57565b9068a20d6e21d0e52553085463ffffffff8160801c16831015611514576114ae907f00000000000000000000000000000000000000000000000000000000000000009060a01c611438565b905f925f5b8381106114c957639f6fb6c960e01b5f5260045ffd5b806001018060011161067b5763ffffffff6114e68360011b612055565b166114f5575b506001016114b3565b828692961461150b5750600180910194906114ec565b93505050915090565b639f6fb6c960e01b5f5260045ffd5b906001600160a01b0381166e22d473030f116ddee9f6b43ac78ba314611551575b61154d916115af565b5490565b600461155c8361135f565b5460581c166115445750505f1990565b805460ff60581b191660589290921b60ff60581b16919091179055565b5f546001600160a01b0316330361159c57565b63118cdaa760e01b5f523360045260245ffd5b9060285260145268a20d6e21d0e525530f5f5260485f20905f602852565b9060285260145268a20d6e21d0e525530b5f5260485f20905f602852565b6004549092906001600160a01b03838116908216149081612046575b50612037576001600160a01b038316611fe0575b6001600160a01b03821615610720576116338361135f565b61163c8361135f565b68a20d6e21d0e5255309546001600160a01b031615610713576040519161018083016001600160401b038111848210176113fc576040525f83525f60208401525f60808401525f60a08401525f60c08401525f60e08401525f6101008401525f6101208401525f6101408401525f610160840152805463ffffffff8160801c16604085015263ffffffff835460801c1660608501528060a01c85116106c0576116f560a082901c8690036001600160601b031683612169565b825460a01c8501906117106001600160601b03831685612169565b611745604086015191877f00000000000000000000000000000000000000000000000000000000000000009160a01c03611438565b808203911102845261175686611410565b15611f78575b50611d73565b68a20d6e21d0e52553085463ffffffff60208501518551928382848360801c1601038060808901528360801b9060801b16908360801b191617928368a20d6e21d0e52553085501916040519260c060a085019180835260051b850101604052836040015260c0830183528261016087015260601c166101208501528351611c53575b505060208201516118c9575b5061014081015180611885575b50610160015180611833575b505f9081526001600160a01b0391821692909116905f8051602061231483398151915290602090a3565b600160206040828060a01b0368a20d6e21d0e5255309541693015192603f19840193849163263c69d6835283601f198301525f825160051b6044019260231901915af19151141615610759575f611809565b600160205f9281838060a01b0368a20d6e21d0e5255309541691015190815160051b60840190607f19830195869360631901915af19151141615610759575f6117fd565b9194610160829492015160208360601b9101526118e582611380565b9463ffffffff6118f584866121d0565b1660e086015268a20d6e21d0e5255308549263ffffffff6119397f00000000000000000000000000000000000000000000000000000000000000008660a01c611438565b9460201c16848111908115021761010087015261196e60608701519563ffffffff602089015188018060c08b0152169061218c565b63ffffffff68a20d6e21d0e52553085460401c169760015b15611bf4575b6101208701515f9063ffffffff8b8116911614611a4257611a3d63ffffffff60018c01169a60e0641fffffffe0631fffffff8360031c1668a20d6e21d0e525531160601b01549260051b16161c63ffffffff165b8060081c685106b710e87292a98760611b0160018260ff161b8019825416179055611a1263ffffffff82168a8d6120c3565b611a3263ffffffff60e08c01511663ffffffff60018c019b169083612260565b6101608a01516122bd565b611986565b949798939291906101008801515b63ffffffff611a645f19830160011b612055565b1615611bd0575f19906001810160081c685106b710e87292a98760611b018054196001830160ff1690811c901b8015611b58575b80611aae575b5050508981119081150217611a50565b600180939450811901167e1f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405601f6101e07a1412563212c14164235266736f7425221143267a4524367526767760fc7b2aaaaaaaba69a69a6db6db6db2cb2cb2ce739ce73def7bdeffffffff860260f81c161b60f71c1692831c63d76453e004161a179082685106b710e87292a98760611b03190160081b17910181108a8211175f03175f8080611a9e565b506001909c9895929c9a9794919a9693965b01805419685106b710e87292a98760611b60088e901c0182118117611b925750600190611b6a565b9c9295989c9a9194979a969396808d60081c685106b710e87292a98760611b018311611bbf575b50611a98565b508c1960ff1690811b901c80611bb9565b611a3d909a999691929394959a6001810188811190811502176101008b01526119e0565b60c0870151860361198c57945094925094509468a20d6e21d0e52553085463ffffffff60201b61010084015160201b169163ffffffff60401b9060401b1690600160201b600160601b031916171768a20d6e21d0e5255308555f6117f0565b602060018860609a9699959a989497981b17910152611c7182611380565b94611c9160408801519563ffffffff895188038060a08c0152169061218c565b60015b15611d5a575b5f945f190194611caa8688612079565b63ffffffff8116905f1982018060021c685106b710e87292a98960611b019060c082549160061b1681811c60018060401b0316901b189055611cf1826101608c01516122bd565b600160ff62ffffff8360081c16685106b710e87292a98760611b0192161b198154169055611d1e8161229f565b611d29575b50611c94565b611d32816121af565b5f90815268a20d6e21d0e525530c6020526040812080546001600160a01b0319169055611d23565b60a08701518503611c9a57935093509390945f806117e4565b9194604086979294970151948651976020880151898110818b18028a1899888b108b8a18028914611f69578a8918898c10028918908190038a52900360208901526001600160a01b0383811690831614611f47576040805163144027d3818301526001600160a01b03858116606080840191909152908516608083015260a08201528a8918898c1002891860c0820181815260059190911b820160e090810190935260208201529081018152610140890152611e2e83611380565b95611e3883611380565b9763ffffffff611e4885846121d0565b1660e08b015260608a01519a81811090821802188a019560015b15611f01575b878b611eac8163ffffffff808f8f90611ea060e09284611e975f9b5f1960408701510190816040880152612079565b169889916120c3565b01511691169083612260565b6101408c015160208151838152019052611ec58161229f565b611ed0575b50611e62565b611ed9816121af565b5f90815268a20d6e21d0e525530c6020526040812080546001600160a01b0319169055611eca565b9960010199868b03611e6857939895509398611f2e92975063ffffffff919650806060870152168361218c565b611f4263ffffffff6040850151168261218c565b611762565b9492978681989593989792971090821802186060840151016060840152611762565b50509492975094509491611762565b611fb7906001600160a01b0388811690881614611fcd575b7f000000000000000000000000000000000000000000000000000000000000000090611438565b606084015180820391110260208401525f61175c565b6040850151855190036060860152611f90565b611fe98361135f565b5460a01c60018060a01b0384165f52600560205260405f205490808211918215612024575b50501561161b576311acc28f60e01b5f5260045ffd5b81039150811161067b5781115f8061200e565b632e13674560e01b5f5260045ffd5b60ff915060a01c16155f611607565b60e08160031c685106b710e87292a98960611b01549160051b161c63ffffffff1690565b60e0908260031c9060601b01549160051b161c63ffffffff1690565b9060e08260031c685106b710e87292a98960611b019260051b1682549182821c1863ffffffff16901b189055565b60e0909291928360031c9060601b019260051b1682549182821c1863ffffffff16901b189055565b63ffffffff165f5268a20d6e21d0e525530a60205260405f2090565b6001600160a01b039061212b9061027b90600160201b8110025f190160011b612055565b541690565b6001600160a01b0361214182612107565b161561035e575f90815268a20d6e21d0e525530c60205260409020546001600160a01b031690565b80546001600160a01b031660a09290921b6001600160a01b031916919091179055565b805463ffffffff60801b191660809290921b63ffffffff60801b16919091179055565b60018160081c68a20d6e21d0e525530d60601b019160ff161b198154169055565b805460601c63ffffffff16929183156121e7575050565b68a20d6e21d0e5255308805463ffffffff19811663ffffffff918216600101918216908117909255835463ffffffff60601b191660609190911b63ffffffff60601b1617909255909250829061223c826120eb565b80546001600160a01b0319166001600160a01b039092169190911790551561075957565b5f1901908160021c685106b710e87292a98960611b019260c084549360061b169163ffffffff169060201b1782821c1860018060401b0316901b189055565b8060081c68a20d6e21d0e525530d60601b01549060ff161c60011690565b9060209082519060081b8284015117815201905256fec2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef608034607857601f610d3538819003918201601f19168301916001600160401b03831184841017607c57808492602094604052833981010312607857516001600160a01b03811690819003607857683602298b8c10b0123180546001600160a01b031916919091179055604051610ca490816100918239f35b5f80fd5b634e487b7160e01b5f52604160045260245ffdfe60808060405260043610156101c5575b5036156101ba575f3560e01c63263c69d681146101405763144027d381146100cf57630f4599e51461004857633c10b94e5f526004601cfd5b683602298b8c10b01231546001600160a01b0316806100ab575b50683602298b8c10b01230546001600160a01b03811661009e576001600160a01b0319163317683602298b8c10b012305560015f908152602090f35b63bf656a465f526004601cfd5b6004356001600160a01b0316036100c2575f610062565b63c59ec47a5f526004601cfd5b683602298b8c10b01230546001600160a01b03163303610133576004356024359060443591602483810193600481013560051b0101925b8381036101165760015f5260205ff35b803582845f80516020610c848339815191525f80a4602001610106565b63363cb3125f526004601cfd5b683602298b8c10b01230546001600160a01b0316330361013357600435602481810191600481013560051b0101905b81810361017f5760015f5260205ff35b8035600881901c6001600160581b03169060018116801560609290921c91820291025f80516020610c848339815191525f80a460200161016f565b346101c157005b5f80fd5b5f3560e01c90816301ffc9a714610aa85750806306fdde0314610a3d578063081812fc146109e6578063095ea7b31461096457806318160ddd1461091857806323b872dd1461090457806324359879146108ad5780632f745c591461083c57806342842e0e146107c95780634f6ccce7146107325780636352211e146107035780636cef16e61461063757806370a08231146105da5780638da5cb5b146105aa57806395d89b411461053f57806397e5311c14610513578063a22cb46514610487578063b88d4fde1461039d578063c87b56dd146103215763e985e9c5146102ad575f61000f565b346101c15760403660031901126101c1576102c6610b1c565b60205f6044601c6102d5610b32565b6102dd610c25565b604080516362fb246d87526001600160a01b039889168852979092169091525afa601f3d1116156103195760405260205f516040519015158152f35b3d5f823e3d90fd5b346101c15760203660031901126101c15760043561033e81610c4f565b505f806024601c61034d610c25565b6040519563cb30b46085526020525afa15610319576103999060205f803e60205f51823e805160205f5101602083013e6040815182015f60208201520160405260405191829182610af2565b0390f35b60803660031901126101c1576103b1610b1c565b6103b9610b32565b60443591606435916001600160401b0383116101c157366023840112156101c1576004830135926001600160401b0384116101c15736602485830101116101c157610405858385610b82565b813b61040d57005b83602094602460a49360405198899763150b7a028952338a8a015260018060a01b0316604089015260608801526080808801528260a08801520160c086013701905f601c8401915af115610479575b5163757a42ff60e11b0161046c57005b63d1a57ed65f526004601cfd5b3d1561045c573d5f823e3d90fd5b346101c15760403660031901126101c1576104a0610b1c565b6024358015158091036101c15760205f6064601c826104bd610c25565b9660018060a01b0316966040519663f6916ddd8352888752604052336060525af160015f511416156103195750337f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3160206040a3005b346101c1575f3660031901126101c157602061052d610c25565b6040516001600160a01b039091168152f35b346101c1575f3660031901126101c157610557610c25565b5f806024601c604051946395d89b418452836020525afa15610319576103999060205f803e60205f51823e805160205f5101602083013e6040815182015f60208201520160405260405191829182610af2565b346101c1575f3660031901126101c157683602298b8c10b01232546040516001600160a01b039091168152602090f35b346101c15760203660031901126101c1576001600160a01b036105fb610b1c565b1660205f6044601c61060b610c25565b6040519563f5b100ea85528552836040525afa601f3d1116156103195760405260205f51604051908152f35b346101c1575f3660031901126101c15761064f610c25565b683602298b8c10b012325460205f6004601c60018060a01b03851695638da5cb5b84525afa9081601f3d1116600c5160601c0291156106ec575b506001600160a01b0316908181036106a7575b602060405160018152f35b683602298b8c10b0123280546001600160a01b031916831790557f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a3808061069c565b60601b6001600160601b0319166101c15782610689565b346101c15760203660031901126101c15760206001600160a01b03610729600435610c4f565b16604051908152f35b346101c15760203660031901126101c157602460206001600160a01b03610757610c25565b1660405192838092634f6ccce760e01b825260043560048301525afa80156107be575f9061078b575b602090604051908152f35b506020813d6020116107b6575b816107a560209383610bee565b810103126101c15760209051610780565b3d9150610798565b6040513d5f823e3d90fd5b6107d236610b48565b916107de838383610b82565b813b6107e657005b60a460209260405194859363150b7a028552338686015260018060a01b0316604085015260608401526080808401525f60a08401525f3681375f601c8401915af115610479575163757a42ff60e11b0161046c57005b346101c15760403660031901126101c157610855610b1c565b60206001600160a01b03610867610c25565b604051632f745c5960e01b81526001600160a01b039094166004850152602480359085015283916044918391165afa80156107be575f9061078b57602090604051908152f35b346101c15760203660031901126101c1576108c6610c25565b60205f6044601c6040519463c016aa5284526004358552836040525afa601f3d1116156103195760408190525f516001600160a01b03168152602090f35b61091661091036610b48565b91610b82565b005b346101c1575f3660031901126101c157610930610c25565b60205f6044601c6040519463e2c792818452838552836040525afa601f3d1116156103195760405260205f51604051908152f35b60403660031901126101c157610978610b1c565b60243590610984610c25565b9060018060a01b03169060205f6064601c6040519463d10b6e0c8452868552876040523360605234905af1601f3d1116156103195750600c5160601c7f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9255f80a4005b346101c15760203660031901126101c1576109ff610c25565b60205f6044601c604051946327ef549584526004358552836040525afa601f3d1116156103195760408190525f516001600160a01b03168152602090f35b346101c1575f3660031901126101c157610a55610c25565b5f806024601c604051946306fdde038452836020525afa15610319576103999060205f803e60205f51823e805160205f5101602083013e6040815182015f60208201520160405260405191829182610af2565b346101c15760203660031901126101c157600435906001600160e01b0319821682036101c15760209160e01c635b5e139f8114906301ffc9a76380ac58cd82149114171715158152f35b602060409281835280519182918282860152018484015e5f828201840152601f01601f1916010190565b600435906001600160a01b03821682036101c157565b602435906001600160a01b03821682036101c157565b60609060031901126101c1576004356001600160a01b03811681036101c157906024356001600160a01b03811681036101c1579060443590565b9060846020610b8f610c25565b6040805163e5eb36c881526001600160a01b03968716848201819052959096169086018190526060860187905233608087015294928391601c83019034905af16001825114161561031957505f80516020610c848339815191525f80a4565b601f909101601f19168101906001600160401b03821190821017610c1157604052565b634e487b7160e01b5f52604160045260245ffd5b683602298b8c10b01230546001600160a01b0316908115610c4257565b635b2a47ae5f526004601cfd5b60205f6044601c610c5e610c25565b60405195632d8a746e85528552836040525afa601f3d111615610319576040525f519056feddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";

declare const _default$4: "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";

declare const _default$3: "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";

declare const _default$2: "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";

declare const _default$1: "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";

declare const _default: "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";

declare const topUpDistributorAbi: readonly [{
    readonly type: "function";
    readonly name: "topUp";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "payable";
}];
declare const airlockAbi: readonly [{
    readonly type: "constructor";
    readonly inputs: readonly [{
        readonly name: "owner_";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "receive";
    readonly stateMutability: "payable";
}, {
    readonly type: "function";
    readonly name: "collectIntegratorFees";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "token";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "collectProtocolFees";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "token";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "create";
    readonly inputs: readonly [{
        readonly name: "createData";
        readonly type: "tuple";
        readonly internalType: "struct CreateParams";
        readonly components: readonly [{
            readonly name: "initialSupply";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "numTokensToSell";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "numeraire";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "tokenFactory";
            readonly type: "address";
            readonly internalType: "contract ITokenFactory";
        }, {
            readonly name: "tokenFactoryData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "governanceFactory";
            readonly type: "address";
            readonly internalType: "contract IGovernanceFactory";
        }, {
            readonly name: "governanceFactoryData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "poolInitializer";
            readonly type: "address";
            readonly internalType: "contract IPoolInitializer";
        }, {
            readonly name: "poolInitializerData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "liquidityMigrator";
            readonly type: "address";
            readonly internalType: "contract ILiquidityMigrator";
        }, {
            readonly name: "liquidityMigratorData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "integrator";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "salt";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
    }];
    readonly outputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "pool";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "governance";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "timelock";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "migrationPool";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getAssetData";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "timelock";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "governance";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "liquidityMigrator";
        readonly type: "address";
        readonly internalType: "contract ILiquidityMigrator";
    }, {
        readonly name: "poolInitializer";
        readonly type: "address";
        readonly internalType: "contract IPoolInitializer";
    }, {
        readonly name: "pool";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "migrationPool";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "numTokensToSell";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "totalSupply";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "integrator";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getModuleState";
    readonly inputs: readonly [{
        readonly name: "module";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "state";
        readonly type: "uint8";
        readonly internalType: "enum ModuleState";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "integratorFees";
    readonly inputs: readonly [{
        readonly name: "integrator";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "token";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "migrate";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "owner";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "protocolFees";
    readonly inputs: readonly [{
        readonly name: "token";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "renounceOwnership";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "setModuleState";
    readonly inputs: readonly [{
        readonly name: "modules";
        readonly type: "address[]";
        readonly internalType: "address[]";
    }, {
        readonly name: "states";
        readonly type: "uint8[]";
        readonly internalType: "enum ModuleState[]";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "transferOwnership";
    readonly inputs: readonly [{
        readonly name: "newOwner";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "event";
    readonly name: "Collect";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "token";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Create";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }, {
        readonly name: "numeraire";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "initializer";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }, {
        readonly name: "poolOrHook";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Migrate";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "pool";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "OwnershipTransferred";
    readonly inputs: readonly [{
        readonly name: "previousOwner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "newOwner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "SetModuleState";
    readonly inputs: readonly [{
        readonly name: "module";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "state";
        readonly type: "uint8";
        readonly indexed: true;
        readonly internalType: "enum ModuleState";
    }];
    readonly anonymous: false;
}, {
    readonly type: "error";
    readonly name: "ArrayLengthsMismatch";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "OwnableInvalidOwner";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }];
}, {
    readonly type: "error";
    readonly name: "OwnableUnauthorizedAccount";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
}, {
    readonly type: "error";
    readonly name: "WrongModuleState";
    readonly inputs: readonly [{
        readonly name: "module";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "expected";
        readonly type: "uint8";
        readonly internalType: "enum ModuleState";
    }, {
        readonly name: "actual";
        readonly type: "uint8";
        readonly internalType: "enum ModuleState";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidTickRange";
    readonly inputs: readonly [{
        readonly name: "tick";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "tickSpacing";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidTickRangeMisordered";
    readonly inputs: readonly [{
        readonly name: "tickLower";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "tickUpper";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidFee";
    readonly inputs: readonly [{
        readonly name: "fee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }];
}, {
    readonly type: "error";
    readonly name: "CannotMigrateInsufficientTick";
    readonly inputs: readonly [{
        readonly name: "targetTick";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "currentTick";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
}, {
    readonly type: "error";
    readonly name: "CannotMintZeroLiquidity";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "MaxShareToBeSoldExceeded";
    readonly inputs: readonly [{
        readonly name: "value";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "PoolAlreadyExited";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolAlreadyInitialized";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolLocked";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotAirlock";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "UnorderedBeneficiaries";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidTotalShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidProtocolOwnerShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidProtocolOwnerBeneficiary";
    readonly inputs: readonly [];
}];
declare const uniswapV3InitializerAbi: readonly [{
    readonly type: "function";
    readonly name: "encodePoolInitializerData";
    readonly inputs: readonly [{
        readonly name: "params";
        readonly type: "tuple";
        readonly components: readonly [{
            readonly name: "numTokensToSell";
            readonly type: "uint256";
        }, {
            readonly name: "startTick";
            readonly type: "int24";
        }, {
            readonly name: "endTick";
            readonly type: "int24";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
        }];
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "pure";
}];
declare const v2MigratorAbi: readonly [{
    readonly type: "function";
    readonly name: "encodeLiquidityMigratorData";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "pure";
}];
declare const v3MigratorAbi: readonly [{
    readonly type: "function";
    readonly name: "encodeLiquidityMigratorData";
    readonly inputs: readonly [{
        readonly name: "fee";
        readonly type: "uint24";
    }, {
        readonly name: "tickSpacing";
        readonly type: "int24";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "pure";
}];
declare const v4MigratorAbi: readonly [{
    readonly type: "function";
    readonly name: "encodeLiquidityMigratorData";
    readonly inputs: readonly [{
        readonly name: "fee";
        readonly type: "uint24";
    }, {
        readonly name: "tickSpacing";
        readonly type: "int24";
    }, {
        readonly name: "lockDuration";
        readonly type: "uint256";
    }, {
        readonly name: "beneficiaries";
        readonly type: "address[]";
    }, {
        readonly name: "percentages";
        readonly type: "uint256[]";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "pure";
}, {
    readonly type: "error";
    readonly name: "TickOutOfRange";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ZeroLiquidity";
    readonly inputs: readonly [];
}];
declare const uniswapV3PoolAbi: readonly [{
    readonly type: "function";
    readonly name: "slot0";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "sqrtPriceX96";
        readonly type: "uint160";
    }, {
        readonly name: "tick";
        readonly type: "int24";
    }, {
        readonly name: "observationIndex";
        readonly type: "uint16";
    }, {
        readonly name: "observationCardinality";
        readonly type: "uint16";
    }, {
        readonly name: "observationCardinalityNext";
        readonly type: "uint16";
    }, {
        readonly name: "feeProtocol";
        readonly type: "uint8";
    }, {
        readonly name: "unlocked";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "liquidity";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint128";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "token0";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "token1";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "fee";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
}];
declare const derc20Abi: readonly [{
    readonly type: "function";
    readonly name: "allowance";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "spender";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "approve";
    readonly inputs: readonly [{
        readonly name: "spender";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "value";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "delegate";
    readonly inputs: readonly [{
        readonly name: "delegatee";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "delegateBySig";
    readonly inputs: readonly [{
        readonly name: "delegatee";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "nonce";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "expiry";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "v";
        readonly type: "uint8";
        readonly internalType: "uint8";
    }, {
        readonly name: "r";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }, {
        readonly name: "s";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "delegates";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getVotes";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPastVotes";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "timepoint";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPastTotalSupply";
    readonly inputs: readonly [{
        readonly name: "timepoint";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "nonces";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "DOMAIN_SEPARATOR";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "balanceOf";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "computeAvailableVestedAmount";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "currentYearStart";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "decimals";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint8";
        readonly internalType: "uint8";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getVestingDataOf";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "totalAmount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "releasedAmount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "isPoolUnlocked";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "lastMintTimestamp";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "name";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "pool";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "release";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "symbol";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "tokenURI";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "totalSupply";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "transfer";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "value";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "transferFrom";
    readonly inputs: readonly [{
        readonly name: "from";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "to";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "value";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "vestedTotalAmount";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingDuration";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingStart";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "yearlyMintRate";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "error";
    readonly name: "MintingNotStartedYet";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ExceedsYearlyMintCap";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "NoMintableAmount";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolLocked";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ArrayLengthsMismatch";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ReleaseAmountInvalid";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "MaxPreMintPerAddressExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "MaxTotalPreMintExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "MaxTotalVestedExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "VestingNotStartedYet";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "MaxYearlyMintRateExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}];
declare const derc20V2Abi: readonly [{
    readonly type: "function";
    readonly name: "allowance";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "spender";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "approve";
    readonly inputs: readonly [{
        readonly name: "spender";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "value";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "delegate";
    readonly inputs: readonly [{
        readonly name: "delegatee";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "delegateBySig";
    readonly inputs: readonly [{
        readonly name: "delegatee";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "nonce";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "expiry";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "v";
        readonly type: "uint8";
        readonly internalType: "uint8";
    }, {
        readonly name: "r";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }, {
        readonly name: "s";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "delegates";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getVotes";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPastVotes";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "timepoint";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPastTotalSupply";
    readonly inputs: readonly [{
        readonly name: "timepoint";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "nonces";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "DOMAIN_SEPARATOR";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "balanceOf";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "computeAvailableVestedAmount";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "currentYearStart";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "decimals";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint8";
        readonly internalType: "uint8";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getVestingDataOf";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "totalAmount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "releasedAmount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "isPoolUnlocked";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "lastMintTimestamp";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "name";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "pool";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "release";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "symbol";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "tokenURI";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "totalSupply";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "transfer";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "value";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "transferFrom";
    readonly inputs: readonly [{
        readonly name: "from";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "to";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "value";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "vestedTotalAmount";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingDuration";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingStart";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "yearlyMintRate";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "error";
    readonly name: "MintingNotStartedYet";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ExceedsYearlyMintCap";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "NoMintableAmount";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolLocked";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ArrayLengthsMismatch";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ReleaseAmountInvalid";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "MaxPreMintPerAddressExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "MaxTotalPreMintExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "MaxTotalVestedExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "VestingNotStartedYet";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "MaxYearlyMintRateExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "function";
    readonly name: "computeAvailableVestedAmount";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "computeAvailableVestedAmount";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getScheduleIdsOf";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256[]";
        readonly internalType: "uint256[]";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "release";
    readonly inputs: readonly [{
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "releaseFor";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "releaseFor";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "totalAllocatedOf";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingOf";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "totalAmount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "releasedAmount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingScheduleCount";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingSchedules";
    readonly inputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "cliff";
        readonly type: "uint64";
        readonly internalType: "uint64";
    }, {
        readonly name: "duration";
        readonly type: "uint64";
        readonly internalType: "uint64";
    }];
    readonly stateMutability: "view";
}];
declare const dopplerERC20V1Abi: readonly [{
    readonly type: "constructor";
    readonly inputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "CLOCK_MODE";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "DOMAIN_SEPARATOR";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "result";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "allowance";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "spender";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "result";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "approve";
    readonly inputs: readonly [{
        readonly name: "spender";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "balanceLimitEnd";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint48";
        readonly internalType: "uint48";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "balanceOf";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "result";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "burn";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "cancelOwnershipHandover";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
    readonly stateMutability: "payable";
}, {
    readonly type: "function";
    readonly name: "checkpointAt";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "i";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "checkpointClock";
        readonly type: "uint48";
        readonly internalType: "uint48";
    }, {
        readonly name: "checkpointValue";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "checkpointCount";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "result";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "clock";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "result";
        readonly type: "uint48";
        readonly internalType: "uint48";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "completeOwnershipHandover";
    readonly inputs: readonly [{
        readonly name: "pendingOwner";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "payable";
}, {
    readonly type: "function";
    readonly name: "computeAvailableVestedAmount";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "computeAvailableVestedAmount";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "total";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "controller";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "decimals";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint8";
        readonly internalType: "uint8";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "delegate";
    readonly inputs: readonly [{
        readonly name: "delegatee";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "delegateBySig";
    readonly inputs: readonly [{
        readonly name: "delegatee";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "nonce";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "expiry";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "v";
        readonly type: "uint8";
        readonly internalType: "uint8";
    }, {
        readonly name: "r";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }, {
        readonly name: "s";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "delegates";
    readonly inputs: readonly [{
        readonly name: "delegator";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "result";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "disableBalanceLimit";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getPastVotes";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "timepoint";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPastVotesTotalSupply";
    readonly inputs: readonly [{
        readonly name: "timepoint";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getScheduleIdsOf";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256[]";
        readonly internalType: "uint256[]";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getVotes";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getVotesTotalSupply";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "initialize";
    readonly inputs: readonly [{
        readonly name: "name_";
        readonly type: "string";
        readonly internalType: "string";
    }, {
        readonly name: "symbol_";
        readonly type: "string";
        readonly internalType: "string";
    }, {
        readonly name: "initialSupply";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "recipient";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "owner_";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "schedules";
        readonly type: "tuple[]";
        readonly internalType: "struct VestingSchedule[]";
        readonly components: readonly [{
            readonly name: "cliff";
            readonly type: "uint64";
            readonly internalType: "uint64";
        }, {
            readonly name: "duration";
            readonly type: "uint64";
            readonly internalType: "uint64";
        }];
    }, {
        readonly name: "beneficiaries";
        readonly type: "address[]";
        readonly internalType: "address[]";
    }, {
        readonly name: "scheduleIds";
        readonly type: "uint256[]";
        readonly internalType: "uint256[]";
    }, {
        readonly name: "amounts";
        readonly type: "uint256[]";
        readonly internalType: "uint256[]";
    }, {
        readonly name: "tokenURI_";
        readonly type: "string";
        readonly internalType: "string";
    }, {
        readonly name: "maxBalanceLimit_";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "balanceLimitEnd_";
        readonly type: "uint48";
        readonly internalType: "uint48";
    }, {
        readonly name: "controller_";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "excludedFromBalanceLimit";
        readonly type: "address[]";
        readonly internalType: "address[]";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "isBalanceLimitActive";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "isExcludedFromBalanceLimit";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "excluded";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "isPoolLocked";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "lockPool";
    readonly inputs: readonly [{
        readonly name: "pool_";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "maxBalanceLimit";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "name";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "nonces";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "result";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "owner";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "result";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "ownershipHandoverExpiresAt";
    readonly inputs: readonly [{
        readonly name: "pendingOwner";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "result";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "permit";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "spender";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "value";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "deadline";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "v";
        readonly type: "uint8";
        readonly internalType: "uint8";
    }, {
        readonly name: "r";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }, {
        readonly name: "s";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "pool";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "release";
    readonly inputs: readonly [{
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "release";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "releaseFor";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "releaseFor";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "renounceOwnership";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
    readonly stateMutability: "payable";
}, {
    readonly type: "function";
    readonly name: "requestOwnershipHandover";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
    readonly stateMutability: "payable";
}, {
    readonly type: "function";
    readonly name: "symbol";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "tokenURI";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "totalAllocatedOf";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "totalSupply";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "result";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "transfer";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "transferFrom";
    readonly inputs: readonly [{
        readonly name: "from";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "to";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "transferOwnership";
    readonly inputs: readonly [{
        readonly name: "newOwner";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "payable";
}, {
    readonly type: "function";
    readonly name: "unlockPool";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "updateTokenURI";
    readonly inputs: readonly [{
        readonly name: "tokenURI_";
        readonly type: "string";
        readonly internalType: "string";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "vestedTotalAmount";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingOf";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "totalAmount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "releasedAmount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingScheduleCount";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingSchedules";
    readonly inputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "cliff";
        readonly type: "uint64";
        readonly internalType: "uint64";
    }, {
        readonly name: "duration";
        readonly type: "uint64";
        readonly internalType: "uint64";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingStart";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "event";
    readonly name: "Approval";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "spender";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "BalanceLimitDisabled";
    readonly inputs: readonly [{
        readonly name: "expired";
        readonly type: "bool";
        readonly indexed: false;
        readonly internalType: "bool";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "DelegateChanged";
    readonly inputs: readonly [{
        readonly name: "delegator";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "from";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "to";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "DelegateVotesChanged";
    readonly inputs: readonly [{
        readonly name: "delegate";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "oldValue";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "newValue";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Initialized";
    readonly inputs: readonly [{
        readonly name: "version";
        readonly type: "uint64";
        readonly indexed: false;
        readonly internalType: "uint64";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "OwnershipHandoverCanceled";
    readonly inputs: readonly [{
        readonly name: "pendingOwner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "OwnershipHandoverRequested";
    readonly inputs: readonly [{
        readonly name: "pendingOwner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "OwnershipTransferred";
    readonly inputs: readonly [{
        readonly name: "oldOwner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "newOwner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "TokensReleased";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly indexed: true;
        readonly internalType: "uint256";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Transfer";
    readonly inputs: readonly [{
        readonly name: "from";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "to";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "UpdateTokenURI";
    readonly inputs: readonly [{
        readonly name: "tokenURI";
        readonly type: "string";
        readonly indexed: false;
        readonly internalType: "string";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "VestingAllocated";
    readonly inputs: readonly [{
        readonly name: "beneficiary";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly indexed: true;
        readonly internalType: "uint256";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "VestingScheduleCreated";
    readonly inputs: readonly [{
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly indexed: true;
        readonly internalType: "uint256";
    }, {
        readonly name: "cliff";
        readonly type: "uint64";
        readonly indexed: false;
        readonly internalType: "uint64";
    }, {
        readonly name: "duration";
        readonly type: "uint64";
        readonly indexed: false;
        readonly internalType: "uint64";
    }];
    readonly anonymous: false;
}, {
    readonly type: "error";
    readonly name: "AllowanceOverflow";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "AllowanceUnderflow";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "AlreadyInitialized";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ArrayLengthsMismatch";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "BalanceLimitExceeded";
    readonly inputs: readonly [{
        readonly name: "balance";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "BalanceLimitNotActive";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ERC5805CheckpointIndexOutOfBounds";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ERC5805CheckpointValueOverflow";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ERC5805CheckpointValueUnderflow";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ERC5805DelegateInvalidSignature";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ERC5805DelegateSignatureExpired";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "ERC5805FutureLookup";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InsufficientAllowance";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InsufficientBalance";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InsufficientReleasableAmount";
    readonly inputs: readonly [{
        readonly name: "available";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "requested";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidAllocation";
    readonly inputs: readonly [{
        readonly name: "index";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidBalanceLimit";
    readonly inputs: readonly [{
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidBalanceLimitTimestamp";
    readonly inputs: readonly [{
        readonly name: "specified";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "current";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidInitialization";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidPermit";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidSchedule";
    readonly inputs: readonly [{
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "MaxPreMintPerAddressExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "MaxTotalPreMintExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "MaxTotalVestedExceeded";
    readonly inputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "NewOwnerIsZeroAddress";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "NoHandoverRequest";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "NoReleasableAmount";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "NotInitializing";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "Permit2AllowanceIsFixedAtInfinity";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PermitExpired";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolAlreadyLocked";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolAlreadyUnlocked";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolLocked";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "TotalSupplyOverflow";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "Unauthorized";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "UnknownScheduleId";
    readonly inputs: readonly [{
        readonly name: "scheduleId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}];
declare const uniswapV4InitializerAbi: readonly [{
    readonly type: "function";
    readonly name: "encodePoolInitializerData";
    readonly inputs: readonly [{
        readonly name: "params";
        readonly type: "tuple";
        readonly components: readonly [{
            readonly name: "minimumProceeds";
            readonly type: "uint256";
        }, {
            readonly name: "maximumProceeds";
            readonly type: "uint256";
        }, {
            readonly name: "startingTime";
            readonly type: "uint256";
        }, {
            readonly name: "endingTime";
            readonly type: "uint256";
        }, {
            readonly name: "startingTick";
            readonly type: "int24";
        }, {
            readonly name: "endingTick";
            readonly type: "int24";
        }, {
            readonly name: "epochLength";
            readonly type: "uint256";
        }, {
            readonly name: "gamma";
            readonly type: "int24";
        }, {
            readonly name: "isToken0";
            readonly type: "bool";
        }, {
            readonly name: "numPDSlugs";
            readonly type: "uint256";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
        }];
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "pure";
}];
declare const dopplerHookAbi: readonly [{
    readonly type: "function";
    readonly name: "state";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "lastEpoch";
        readonly type: "uint40";
    }, {
        readonly name: "tickAccumulator";
        readonly type: "int256";
    }, {
        readonly name: "totalTokensSold";
        readonly type: "uint256";
    }, {
        readonly name: "totalProceeds";
        readonly type: "uint256";
    }, {
        readonly name: "totalTokensSoldLastEpoch";
        readonly type: "uint256";
    }, {
        readonly name: "feesAccrued";
        readonly type: "int256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "earlyExit";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "insufficientProceeds";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "poolKey";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "currency0";
        readonly type: "address";
    }, {
        readonly name: "currency1";
        readonly type: "address";
    }, {
        readonly name: "fee";
        readonly type: "uint24";
    }, {
        readonly name: "tickSpacing";
        readonly type: "int24";
    }, {
        readonly name: "hooks";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "startingTime";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "endingTime";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "epochLength";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "minimumProceeds";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "maximumProceeds";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "numTokensToSell";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "startingTick";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "int24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "endingTick";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "int24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "gamma";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "int24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "isToken0";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "numPDSlugs";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "error";
    readonly name: "InvalidGamma";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidTimeRange";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "CannotAddLiquidity";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "CannotSwapBeforeStartTime";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SwapBelowRange";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidStartTime";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidTickRange";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidTickSpacing";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidEpochLength";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidProceedLimits";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidNumPDSlugs";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidSwapAfterMaturitySufficientProceeds";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidSwapAfterMaturityInsufficientProceeds";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "MaximumProceedsReached";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotPoolManager";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "AlreadyInitialized";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotInitializer";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "CannotMigrate";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "CannotDonate";
    readonly inputs: readonly [];
}];
declare const openingAuctionAbi: readonly [{
    readonly type: "function";
    readonly name: "phase";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint8";
        readonly internalType: "enum AuctionPhase";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "auctionStartTime";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "auctionEndTime";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "clearingTick";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "totalTokensSold";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "totalProceeds";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "incentiveTokensTotal";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "totalAuctionTokens";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "totalIncentivesClaimed";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "incentivesClaimDeadline";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "positions";
    readonly inputs: readonly [{
        readonly name: "positionId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "tuple";
        readonly internalType: "struct AuctionPosition";
        readonly components: readonly [{
            readonly name: "owner";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "tickLower";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "tickUpper";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "liquidity";
            readonly type: "uint128";
            readonly internalType: "uint128";
        }, {
            readonly name: "rewardDebtX128";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "hasClaimedIncentives";
            readonly type: "bool";
            readonly internalType: "bool";
        }];
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "isInRange";
    readonly inputs: readonly [{
        readonly name: "positionId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "calculateIncentives";
    readonly inputs: readonly [{
        readonly name: "positionId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "settleAuction";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "claimIncentives";
    readonly inputs: readonly [{
        readonly name: "positionId";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "estimatedClearingTick";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "liquidityAtTick";
    readonly inputs: readonly [{
        readonly name: "tick";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "nextPositionId";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "ownerPositions";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "index";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "isToken0";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "poolKey";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "minLiquidity";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "minAcceptableTickToken0";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "minAcceptableTickToken1";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "event";
    readonly name: "AuctionSettled";
    readonly inputs: readonly [{
        readonly name: "clearingTick";
        readonly type: "int24";
        readonly indexed: false;
        readonly internalType: "int24";
    }, {
        readonly name: "tokensSold";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "proceeds";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "BidPlaced";
    readonly inputs: readonly [{
        readonly name: "positionId";
        readonly type: "uint256";
        readonly indexed: true;
        readonly internalType: "uint256";
    }, {
        readonly name: "owner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "tickLower";
        readonly type: "int24";
        readonly indexed: false;
        readonly internalType: "int24";
    }, {
        readonly name: "liquidity";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "BidWithdrawn";
    readonly inputs: readonly [{
        readonly name: "positionId";
        readonly type: "uint256";
        readonly indexed: true;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "IncentivesClaimed";
    readonly inputs: readonly [{
        readonly name: "positionId";
        readonly type: "uint256";
        readonly indexed: true;
        readonly internalType: "uint256";
    }, {
        readonly name: "owner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "EstimatedClearingTickUpdated";
    readonly inputs: readonly [{
        readonly name: "newEstimatedClearingTick";
        readonly type: "int24";
        readonly indexed: false;
        readonly internalType: "int24";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "PhaseChanged";
    readonly inputs: readonly [{
        readonly name: "oldPhase";
        readonly type: "uint8";
        readonly indexed: true;
        readonly internalType: "uint8";
    }, {
        readonly name: "newPhase";
        readonly type: "uint8";
        readonly indexed: true;
        readonly internalType: "uint8";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "AuctionStarted";
    readonly inputs: readonly [{
        readonly name: "auctionStartTime";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "auctionEndTime";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "totalAuctionTokens";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "incentiveTokensTotal";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "TickEnteredRange";
    readonly inputs: readonly [{
        readonly name: "tick";
        readonly type: "int24";
        readonly indexed: true;
        readonly internalType: "int24";
    }, {
        readonly name: "liquidity";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "TickExitedRange";
    readonly inputs: readonly [{
        readonly name: "tick";
        readonly type: "int24";
        readonly indexed: true;
        readonly internalType: "int24";
    }, {
        readonly name: "liquidity";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "LiquidityAddedToTick";
    readonly inputs: readonly [{
        readonly name: "tick";
        readonly type: "int24";
        readonly indexed: true;
        readonly internalType: "int24";
    }, {
        readonly name: "liquidityAdded";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }, {
        readonly name: "totalLiquidity";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "LiquidityRemovedFromTick";
    readonly inputs: readonly [{
        readonly name: "tick";
        readonly type: "int24";
        readonly indexed: true;
        readonly internalType: "int24";
    }, {
        readonly name: "liquidityRemoved";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }, {
        readonly name: "remainingLiquidity";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "TimeHarvested";
    readonly inputs: readonly [{
        readonly name: "positionId";
        readonly type: "uint256";
        readonly indexed: true;
        readonly internalType: "uint256";
    }, {
        readonly name: "harvestedTimeX128";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "IncentivesRecovered";
    readonly inputs: readonly [{
        readonly name: "recipient";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}];
declare const openingAuctionInitializerAbi: readonly [{
    readonly type: "function";
    readonly name: "initialize";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "numTokensToSell";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "salt";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }, {
        readonly name: "data";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "poolManager";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract IPoolManager";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "auctionDeployer";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract OpeningAuctionDeployer";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "dopplerDeployer";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract IDopplerDeployer";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "positionManager";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getState";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "auctionStartTime";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "auctionEndTime";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "auctionTokens";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "dopplerTokens";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "status";
        readonly type: "uint8";
        readonly internalType: "enum OpeningAuctionStatus";
    }, {
        readonly name: "openingAuctionHook";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "dopplerHook";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "openingAuctionPoolKey";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "dopplerInitData";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }, {
        readonly name: "isToken0";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getOpeningAuctionHook";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getDopplerHook";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "completeAuction";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "dopplerSalt";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "recoverOpeningAuctionIncentives";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "sweepOpeningAuctionIncentives";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "event";
    readonly name: "AuctionCompleted";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "clearingTick";
        readonly type: "int24";
        readonly indexed: false;
        readonly internalType: "int24";
    }, {
        readonly name: "tokensSold";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "proceeds";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}];
declare const openingAuctionPositionManagerAbi: readonly [{
    readonly type: "function";
    readonly name: "poolManager";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract IPoolManager";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "modifyLiquidity";
    readonly inputs: readonly [{
        readonly name: "key";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "params";
        readonly type: "tuple";
        readonly internalType: "struct IPoolManager.ModifyLiquidityParams";
        readonly components: readonly [{
            readonly name: "tickLower";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "tickUpper";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "liquidityDelta";
            readonly type: "int256";
            readonly internalType: "int256";
        }, {
            readonly name: "salt";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
    }, {
        readonly name: "hookData";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }];
    readonly outputs: readonly [{
        readonly name: "delta";
        readonly type: "int256";
        readonly internalType: "BalanceDelta";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "modifyLiquidity";
    readonly inputs: readonly [{
        readonly name: "key";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "params";
        readonly type: "tuple";
        readonly internalType: "struct IPoolManager.ModifyLiquidityParams";
        readonly components: readonly [{
            readonly name: "tickLower";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "tickUpper";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "liquidityDelta";
            readonly type: "int256";
            readonly internalType: "int256";
        }, {
            readonly name: "salt";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
    }];
    readonly outputs: readonly [{
        readonly name: "delta";
        readonly type: "int256";
        readonly internalType: "BalanceDelta";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "error";
    readonly name: "WrappedError";
    readonly inputs: readonly [{
        readonly name: "target";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "selector";
        readonly type: "bytes4";
        readonly internalType: "bytes4";
    }, {
        readonly name: "reason";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }, {
        readonly name: "details";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }];
}, {
    readonly type: "error";
    readonly name: "HookCallFailed";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PositionIsLocked";
    readonly inputs: readonly [];
}];
declare const quoterV2Abi: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_factory";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_WETH9";
        readonly type: "address";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [];
    readonly name: "WETH9";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "factory";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes";
        readonly name: "path";
        readonly type: "bytes";
    }, {
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }];
    readonly name: "quoteExactInput";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amountOut";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint160[]";
        readonly name: "sqrtPriceX96AfterList";
        readonly type: "uint160[]";
    }, {
        readonly internalType: "uint32[]";
        readonly name: "initializedTicksCrossedList";
        readonly type: "uint32[]";
    }, {
        readonly internalType: "uint256";
        readonly name: "gasEstimate";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "address";
            readonly name: "tokenIn";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "tokenOut";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amountIn";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint24";
            readonly name: "fee";
            readonly type: "uint24";
        }, {
            readonly internalType: "uint160";
            readonly name: "sqrtPriceLimitX96";
            readonly type: "uint160";
        }];
        readonly internalType: "struct IQuoterV2.QuoteExactInputSingleParams";
        readonly name: "params";
        readonly type: "tuple";
    }];
    readonly name: "quoteExactInputSingle";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amountOut";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint160";
        readonly name: "sqrtPriceX96After";
        readonly type: "uint160";
    }, {
        readonly internalType: "uint32";
        readonly name: "initializedTicksCrossed";
        readonly type: "uint32";
    }, {
        readonly internalType: "uint256";
        readonly name: "gasEstimate";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes";
        readonly name: "path";
        readonly type: "bytes";
    }, {
        readonly internalType: "uint256";
        readonly name: "amountOut";
        readonly type: "uint256";
    }];
    readonly name: "quoteExactOutput";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint160[]";
        readonly name: "sqrtPriceX96AfterList";
        readonly type: "uint160[]";
    }, {
        readonly internalType: "uint32[]";
        readonly name: "initializedTicksCrossedList";
        readonly type: "uint32[]";
    }, {
        readonly internalType: "uint256";
        readonly name: "gasEstimate";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "address";
            readonly name: "tokenIn";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "tokenOut";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint24";
            readonly name: "fee";
            readonly type: "uint24";
        }, {
            readonly internalType: "uint160";
            readonly name: "sqrtPriceLimitX96";
            readonly type: "uint160";
        }];
        readonly internalType: "struct IQuoterV2.QuoteExactOutputSingleParams";
        readonly name: "params";
        readonly type: "tuple";
    }];
    readonly name: "quoteExactOutputSingle";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint160";
        readonly name: "sqrtPriceX96After";
        readonly type: "uint160";
    }, {
        readonly internalType: "uint32";
        readonly name: "initializedTicksCrossed";
        readonly type: "uint32";
    }, {
        readonly internalType: "uint256";
        readonly name: "gasEstimate";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "int256";
        readonly name: "amount0Delta";
        readonly type: "int256";
    }, {
        readonly internalType: "int256";
        readonly name: "amount1Delta";
        readonly type: "int256";
    }, {
        readonly internalType: "bytes";
        readonly name: "_data";
        readonly type: "bytes";
    }];
    readonly name: "uniswapV3SwapCallback";
    readonly outputs: readonly [];
    readonly stateMutability: "view";
    readonly type: "function";
}];
declare const uniswapV2Router02Abi: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }, {
        readonly internalType: "address[]";
        readonly name: "path";
        readonly type: "address[]";
    }];
    readonly name: "getAmountsOut";
    readonly outputs: readonly [{
        readonly internalType: "uint256[]";
        readonly name: "amounts";
        readonly type: "uint256[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amountOut";
        readonly type: "uint256";
    }, {
        readonly internalType: "address[]";
        readonly name: "path";
        readonly type: "address[]";
    }];
    readonly name: "getAmountsIn";
    readonly outputs: readonly [{
        readonly internalType: "uint256[]";
        readonly name: "amounts";
        readonly type: "uint256[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];
declare const v4QuoterAbi: readonly [{
    readonly type: "constructor";
    readonly inputs: readonly [{
        readonly name: "_poolManager";
        readonly type: "address";
        readonly internalType: "contract IPoolManager";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "quoteExactInputSingle";
    readonly inputs: readonly [{
        readonly name: "params";
        readonly type: "tuple";
        readonly internalType: "struct IV4Quoter.QuoteExactSingleParams";
        readonly components: readonly [{
            readonly name: "poolKey";
            readonly type: "tuple";
            readonly internalType: "struct PoolKey";
            readonly components: readonly [{
                readonly name: "currency0";
                readonly type: "address";
                readonly internalType: "Currency";
            }, {
                readonly name: "currency1";
                readonly type: "address";
                readonly internalType: "Currency";
            }, {
                readonly name: "fee";
                readonly type: "uint24";
                readonly internalType: "uint24";
            }, {
                readonly name: "tickSpacing";
                readonly type: "int24";
                readonly internalType: "int24";
            }, {
                readonly name: "hooks";
                readonly type: "address";
                readonly internalType: "contract IHooks";
            }];
        }, {
            readonly name: "zeroForOne";
            readonly type: "bool";
            readonly internalType: "bool";
        }, {
            readonly name: "exactAmount";
            readonly type: "uint128";
            readonly internalType: "uint128";
        }, {
            readonly name: "hookData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }];
    }];
    readonly outputs: readonly [{
        readonly name: "amountOut";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "gasEstimate";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "quoteExactOutputSingle";
    readonly inputs: readonly [{
        readonly name: "params";
        readonly type: "tuple";
        readonly internalType: "struct IV4Quoter.QuoteExactSingleParams";
        readonly components: readonly [{
            readonly name: "poolKey";
            readonly type: "tuple";
            readonly internalType: "struct PoolKey";
            readonly components: readonly [{
                readonly name: "currency0";
                readonly type: "address";
                readonly internalType: "Currency";
            }, {
                readonly name: "currency1";
                readonly type: "address";
                readonly internalType: "Currency";
            }, {
                readonly name: "fee";
                readonly type: "uint24";
                readonly internalType: "uint24";
            }, {
                readonly name: "tickSpacing";
                readonly type: "int24";
                readonly internalType: "int24";
            }, {
                readonly name: "hooks";
                readonly type: "address";
                readonly internalType: "contract IHooks";
            }];
        }, {
            readonly name: "zeroForOne";
            readonly type: "bool";
            readonly internalType: "bool";
        }, {
            readonly name: "exactAmount";
            readonly type: "uint128";
            readonly internalType: "uint128";
        }, {
            readonly name: "hookData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }];
    }];
    readonly outputs: readonly [{
        readonly name: "amountIn";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "gasEstimate";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "poolManager";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract IPoolManager";
    }];
    readonly stateMutability: "view";
}];
declare const lockableUniswapV3InitializerAbi: readonly [{
    readonly type: "constructor";
    readonly inputs: readonly [{
        readonly name: "airlock_";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "factory_";
        readonly type: "address";
        readonly internalType: "contract IUniswapV3Factory";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "airlock";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract Airlock";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "pool";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0ToDistribute";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1ToDistribute";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "exitLiquidity";
    readonly inputs: readonly [{
        readonly name: "pool";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "sqrtPriceX96";
        readonly type: "uint160";
        readonly internalType: "uint160";
    }, {
        readonly name: "token0";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "balance0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "token1";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "balance1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "factory";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract IUniswapV3Factory";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getState";
    readonly inputs: readonly [{
        readonly name: "pool";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "tickLower";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "tickUpper";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "maxShareToBeSold";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "totalTokensOnBondingCurve";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "status";
        readonly type: "uint8";
        readonly internalType: "enum PoolStatus";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "initialize";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "totalTokensOnBondingCurve";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }, {
        readonly name: "data";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }];
    readonly outputs: readonly [{
        readonly name: "pool";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "uniswapV3MintCallback";
    readonly inputs: readonly [{
        readonly name: "amount0Owed";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "amount1Owed";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "data";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "encodePoolInitializerData";
    readonly inputs: readonly [{
        readonly name: "params";
        readonly type: "tuple";
        readonly components: readonly [{
            readonly name: "fee";
            readonly type: "uint24";
        }, {
            readonly name: "tickLower";
            readonly type: "int24";
        }, {
            readonly name: "tickUpper";
            readonly type: "int24";
        }, {
            readonly name: "numPositions";
            readonly type: "uint16";
        }, {
            readonly name: "maxShareToBeSold";
            readonly type: "uint256";
        }, {
            readonly name: "beneficiaries";
            readonly type: "tuple[]";
            readonly components: readonly [{
                readonly name: "beneficiary";
                readonly type: "address";
            }, {
                readonly name: "shares";
                readonly type: "uint96";
            }];
        }];
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "pure";
}, {
    readonly type: "event";
    readonly name: "Collect";
    readonly inputs: readonly [{
        readonly name: "pool";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "beneficiary";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "fees0";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Create";
    readonly inputs: readonly [{
        readonly name: "poolOrHook";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "asset";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "numeraire";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Lock";
    readonly inputs: readonly [{
        readonly name: "pool";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "beneficiaries";
        readonly type: "tuple[]";
        readonly indexed: false;
        readonly internalType: "struct BeneficiaryData[]";
        readonly components: readonly [{
            readonly name: "beneficiary";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "shares";
            readonly type: "uint96";
            readonly internalType: "uint96";
        }];
    }];
    readonly anonymous: false;
}, {
    readonly type: "error";
    readonly name: "CannotMigrateInsufficientTick";
    readonly inputs: readonly [{
        readonly name: "targetTick";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "currentTick";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
}, {
    readonly type: "error";
    readonly name: "CannotMintZeroLiquidity";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidFee";
    readonly inputs: readonly [{
        readonly name: "fee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidTickRange";
    readonly inputs: readonly [{
        readonly name: "tick";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "tickSpacing";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidTickRangeMisordered";
    readonly inputs: readonly [{
        readonly name: "tickLower";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "tickUpper";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
}, {
    readonly type: "error";
    readonly name: "MaxShareToBeSoldExceeded";
    readonly inputs: readonly [{
        readonly name: "value";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "limit";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "OnlyPool";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolAlreadyExited";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolAlreadyInitialized";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolLocked";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotAirlock";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "UnorderedBeneficiaries";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidTotalShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidProtocolOwnerShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidProtocolOwnerBeneficiary";
    readonly inputs: readonly [];
}];
declare const v4MulticurveInitializerAbi: readonly [{
    readonly type: "function";
    readonly name: "airlock";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract Airlock";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "HOOK";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract IHooks";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getState";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "status";
        readonly type: "uint8";
        readonly internalType: "enum PoolStatus";
    }, {
        readonly name: "poolKey";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "farTick";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "event";
    readonly name: "Collect";
    readonly inputs: readonly [{
        readonly name: "pool";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "beneficiary";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "fees0";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Create";
    readonly inputs: readonly [{
        readonly name: "poolOrHook";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "asset";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "numeraire";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Lock";
    readonly inputs: readonly [{
        readonly name: "pool";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "beneficiaries";
        readonly type: "tuple[]";
        readonly indexed: false;
        readonly internalType: "struct BeneficiaryData[]";
        readonly components: readonly [{
            readonly name: "beneficiary";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "shares";
            readonly type: "uint96";
            readonly internalType: "uint96";
        }];
    }];
    readonly anonymous: false;
}, {
    readonly type: "error";
    readonly name: "PoolLocked";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolNotLocked";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolAlreadyInitialized";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolAlreadyExited";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "CannotMigrateInsufficientTick";
    readonly inputs: readonly [{
        readonly name: "targetTick";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "currentTick";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
}, {
    readonly type: "error";
    readonly name: "SenderNotAirlock";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "UnorderedBeneficiaries";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidTotalShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidProtocolOwnerShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidProtocolOwnerBeneficiary";
    readonly inputs: readonly [];
}];
declare const dopplerHookInitializerAbi: readonly [{
    readonly type: "function";
    readonly name: "airlock";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract Airlock";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getState";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "totalTokensOnBondingCurve";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "dopplerHook";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "graduationDopplerHookCalldata";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }, {
        readonly name: "status";
        readonly type: "uint8";
        readonly internalType: "enum PoolStatus";
    }, {
        readonly name: "poolKey";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "farTick";
        readonly type: "int24";
        readonly internalType: "int24";
    }];
    readonly stateMutability: "view";
}];
declare const decayMulticurveInitializerHookAbi: readonly [{
    readonly type: "function";
    readonly name: "getFeeScheduleOf";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "startingTime";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }, {
        readonly name: "startFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "endFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "lastFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "durationSeconds";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }];
    readonly stateMutability: "view";
}];
declare const streamableFeesLockerAbi: readonly [{
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "streams";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "poolKey";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "recipient";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "startDate";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }, {
        readonly name: "lockDuration";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }, {
        readonly name: "isUnlocked";
        readonly type: "bool";
        readonly internalType: "bool";
    }, {
        readonly name: "beneficiaries";
        readonly type: "tuple[]";
        readonly internalType: "struct BeneficiaryData[]";
        readonly components: readonly [{
            readonly name: "beneficiary";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "shares";
            readonly type: "uint96";
            readonly internalType: "uint96";
        }];
    }, {
        readonly name: "positions";
        readonly type: "tuple[]";
        readonly internalType: "struct Position[]";
        readonly components: readonly [{
            readonly name: "tickLower";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "tickUpper";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "liquidity";
            readonly type: "uint128";
            readonly internalType: "uint128";
        }, {
            readonly name: "salt";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "error";
    readonly name: "NonPositionManager";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "NotApprovedMigrator";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PositionNotFound";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PositionAlreadyUnlocked";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidBeneficiary";
    readonly inputs: readonly [];
}];
declare const streamableFeesLockerV2Abi: readonly [{
    readonly type: "function";
    readonly name: "approvedMigrators";
    readonly stateMutability: "view";
    readonly inputs: readonly [{
        readonly name: "migrator";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "approved";
        readonly type: "bool";
    }];
}];
declare const v4MulticurveMigratorAbi: readonly [{
    readonly type: "function";
    readonly name: "getAssetData";
    readonly inputs: readonly [{
        readonly name: "token0";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "token1";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "isToken0";
        readonly type: "bool";
        readonly internalType: "bool";
    }, {
        readonly name: "poolKey";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "lockDuration";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }, {
        readonly name: "curves";
        readonly type: "tuple[]";
        readonly internalType: "struct Curve[]";
        readonly components: readonly [{
            readonly name: "tickLower";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "tickUpper";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "numPositions";
            readonly type: "uint16";
            readonly internalType: "uint16";
        }, {
            readonly name: "shares";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
    }, {
        readonly name: "beneficiaries";
        readonly type: "tuple[]";
        readonly internalType: "struct BeneficiaryData[]";
        readonly components: readonly [{
            readonly name: "beneficiary";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "shares";
            readonly type: "uint96";
            readonly internalType: "uint96";
        }];
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "locker";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract StreamableFeesLockerV2";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "error";
    readonly name: "PoolNotInitialized";
    readonly inputs: readonly [];
}];
declare const dopplerLensAbi: readonly [{
    readonly type: "function";
    readonly name: "quoteDopplerLensData";
    readonly inputs: readonly [{
        readonly name: "params";
        readonly type: "tuple";
        readonly internalType: "struct IV4Quoter.QuoteExactSingleParams";
        readonly components: readonly [{
            readonly name: "poolKey";
            readonly type: "tuple";
            readonly internalType: "struct PoolKey";
            readonly components: readonly [{
                readonly name: "currency0";
                readonly type: "address";
                readonly internalType: "Currency";
            }, {
                readonly name: "currency1";
                readonly type: "address";
                readonly internalType: "Currency";
            }, {
                readonly name: "fee";
                readonly type: "uint24";
                readonly internalType: "uint24";
            }, {
                readonly name: "tickSpacing";
                readonly type: "int24";
                readonly internalType: "int24";
            }, {
                readonly name: "hooks";
                readonly type: "address";
                readonly internalType: "contract IHooks";
            }];
        }, {
            readonly name: "zeroForOne";
            readonly type: "bool";
            readonly internalType: "bool";
        }, {
            readonly name: "exactAmount";
            readonly type: "uint128";
            readonly internalType: "uint128";
        }, {
            readonly name: "hookData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }];
    }];
    readonly outputs: readonly [{
        readonly name: "returnData";
        readonly type: "tuple";
        readonly internalType: "struct DopplerLensReturnData";
        readonly components: readonly [{
            readonly name: "sqrtPriceX96";
            readonly type: "uint160";
            readonly internalType: "uint160";
        }, {
            readonly name: "amount0";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "amount1";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "tick";
            readonly type: "int24";
            readonly internalType: "int24";
        }];
    }];
    readonly stateMutability: "nonpayable";
}];
declare const bundlerAbi: readonly [{
    readonly type: "function";
    readonly name: "airlock";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract Airlock";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "poolManager";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract IPoolManager";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "vestingOf";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "recipient";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "permissionlessClaim";
        readonly type: "bool";
        readonly internalType: "bool";
    }, {
        readonly name: "start";
        readonly type: "uint64";
        readonly internalType: "uint64";
    }, {
        readonly name: "cliffDuration";
        readonly type: "uint64";
        readonly internalType: "uint64";
    }, {
        readonly name: "vestingDuration";
        readonly type: "uint64";
        readonly internalType: "uint64";
    }, {
        readonly name: "totalAmount";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "claimedAmount";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "claimable";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "claim";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "bundle";
    readonly inputs: readonly [{
        readonly name: "createData";
        readonly type: "tuple";
        readonly internalType: "struct CreateParams";
        readonly components: readonly [{
            readonly name: "initialSupply";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "numTokensToSell";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "numeraire";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "tokenFactory";
            readonly type: "address";
            readonly internalType: "contract ITokenFactory";
        }, {
            readonly name: "tokenFactoryData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "governanceFactory";
            readonly type: "address";
            readonly internalType: "contract IGovernanceFactory";
        }, {
            readonly name: "governanceFactoryData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "poolInitializer";
            readonly type: "address";
            readonly internalType: "contract IPoolInitializer";
        }, {
            readonly name: "poolInitializerData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "liquidityMigrator";
            readonly type: "address";
            readonly internalType: "contract ILiquidityMigrator";
        }, {
            readonly name: "liquidityMigratorData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "integrator";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "salt";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
    }, {
        readonly name: "vestingData";
        readonly type: "tuple";
        readonly internalType: "struct Bundler.VestingParams";
        readonly components: readonly [{
            readonly name: "permissionlessClaim";
            readonly type: "bool";
            readonly internalType: "bool";
        }, {
            readonly name: "vestingDuration";
            readonly type: "uint64";
            readonly internalType: "uint64";
        }, {
            readonly name: "cliffDuration";
            readonly type: "uint64";
            readonly internalType: "uint64";
        }];
    }, {
        readonly name: "exactAmountIn";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "recipient";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "poolKey";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "governance";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "timelock";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amountOut";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "payable";
}, {
    readonly type: "function";
    readonly name: "simulateBundle";
    readonly inputs: readonly [{
        readonly name: "createData";
        readonly type: "tuple";
        readonly internalType: "struct CreateParams";
        readonly components: readonly [{
            readonly name: "initialSupply";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "numTokensToSell";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "numeraire";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "tokenFactory";
            readonly type: "address";
            readonly internalType: "contract ITokenFactory";
        }, {
            readonly name: "tokenFactoryData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "governanceFactory";
            readonly type: "address";
            readonly internalType: "contract IGovernanceFactory";
        }, {
            readonly name: "governanceFactoryData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "poolInitializer";
            readonly type: "address";
            readonly internalType: "contract IPoolInitializer";
        }, {
            readonly name: "poolInitializerData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "liquidityMigrator";
            readonly type: "address";
            readonly internalType: "contract ILiquidityMigrator";
        }, {
            readonly name: "liquidityMigratorData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "integrator";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "salt";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
    }, {
        readonly name: "exactAmountIn";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly outputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "poolKey";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "governance";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "timelock";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amountOut";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "_simulateBundle";
    readonly inputs: readonly [{
        readonly name: "createData";
        readonly type: "tuple";
        readonly internalType: "struct CreateParams";
        readonly components: readonly [{
            readonly name: "initialSupply";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "numTokensToSell";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "numeraire";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "tokenFactory";
            readonly type: "address";
            readonly internalType: "contract ITokenFactory";
        }, {
            readonly name: "tokenFactoryData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "governanceFactory";
            readonly type: "address";
            readonly internalType: "contract IGovernanceFactory";
        }, {
            readonly name: "governanceFactoryData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "poolInitializer";
            readonly type: "address";
            readonly internalType: "contract IPoolInitializer";
        }, {
            readonly name: "poolInitializerData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "liquidityMigrator";
            readonly type: "address";
            readonly internalType: "contract ILiquidityMigrator";
        }, {
            readonly name: "liquidityMigratorData";
            readonly type: "bytes";
            readonly internalType: "bytes";
        }, {
            readonly name: "integrator";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "salt";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
    }, {
        readonly name: "exactAmountIn";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "unlockCallback";
    readonly inputs: readonly [{
        readonly name: "data";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "event";
    readonly name: "Bundled";
    readonly inputs: readonly [{
        readonly name: "recipient";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "amountIn";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }, {
        readonly name: "amountOut";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }, {
        readonly name: "poolKey";
        readonly type: "tuple";
        readonly indexed: false;
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "VestingCreated";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "recipient";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "permissionlessClaim";
        readonly type: "bool";
        readonly indexed: false;
        readonly internalType: "bool";
    }, {
        readonly name: "totalAmount";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }, {
        readonly name: "start";
        readonly type: "uint64";
        readonly indexed: false;
        readonly internalType: "uint64";
    }, {
        readonly name: "cliffDuration";
        readonly type: "uint64";
        readonly indexed: false;
        readonly internalType: "uint64";
    }, {
        readonly name: "vestingDuration";
        readonly type: "uint64";
        readonly indexed: false;
        readonly internalType: "uint64";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "VestingReleased";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "recipient";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }];
    readonly anonymous: false;
}, {
    readonly type: "error";
    readonly name: "BundleQuote";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "poolKey";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "governance";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "timelock";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amountOut";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
}, {
    readonly type: "error";
    readonly name: "ExactInputNotFullySpent";
    readonly inputs: readonly [{
        readonly name: "expected";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "actual";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
}, {
    readonly type: "error";
    readonly name: "ExactInputAmountZero";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidAddress";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidNativeValue";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidPool";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidRecipient";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidVestingSchedule";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "NoClaimableAmount";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotPoolManager";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotRecipient";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotSelf";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SwapQuote";
    readonly inputs: readonly [{
        readonly name: "amountOut";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
}, {
    readonly type: "error";
    readonly name: "UnexpectedSimulationSuccess";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "VestingAlreadyExists";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
}];
declare const poolManagerAbi: readonly [{
    readonly type: "function";
    readonly name: "swap";
    readonly inputs: readonly [{
        readonly name: "key";
        readonly type: "tuple";
        readonly internalType: "struct PoolKey";
        readonly components: readonly [{
            readonly name: "currency0";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "currency1";
            readonly type: "address";
            readonly internalType: "Currency";
        }, {
            readonly name: "fee";
            readonly type: "uint24";
            readonly internalType: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
            readonly internalType: "int24";
        }, {
            readonly name: "hooks";
            readonly type: "address";
            readonly internalType: "contract IHooks";
        }];
    }, {
        readonly name: "params";
        readonly type: "tuple";
        readonly internalType: "struct IPoolManager.SwapParams";
        readonly components: readonly [{
            readonly name: "zeroForOne";
            readonly type: "bool";
            readonly internalType: "bool";
        }, {
            readonly name: "amountSpecified";
            readonly type: "int256";
            readonly internalType: "int256";
        }, {
            readonly name: "sqrtPriceLimitX96";
            readonly type: "uint160";
            readonly internalType: "uint160";
        }];
    }, {
        readonly name: "hookData";
        readonly type: "bytes";
        readonly internalType: "bytes";
    }];
    readonly outputs: readonly [{
        readonly name: "swapDelta";
        readonly type: "int256";
        readonly internalType: "BalanceDelta";
    }];
    readonly stateMutability: "nonpayable";
}];
declare const weth9Abi: readonly [{
    readonly type: "function";
    readonly name: "deposit";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
    readonly stateMutability: "payable";
}, {
    readonly type: "function";
    readonly name: "withdraw";
    readonly inputs: readonly [{
        readonly name: "wad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "approve";
    readonly inputs: readonly [{
        readonly name: "spender";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
        readonly internalType: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "balanceOf";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}];
declare const rehypeDopplerHookInitializerAbi: readonly [{
    readonly type: "function";
    readonly name: "getCumulatedFees0";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getCumulatedFees1";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getLastCumulatedFees0";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getLastCumulatedFees1";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getShares";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getPoolKey";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "currency0";
        readonly type: "address";
        readonly internalType: "Currency";
    }, {
        readonly name: "currency1";
        readonly type: "address";
        readonly internalType: "Currency";
    }, {
        readonly name: "fee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "tickSpacing";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "hooks";
        readonly type: "address";
        readonly internalType: "contract IHooks";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "updateBeneficiary";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "newBeneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "event";
    readonly name: "Collect";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "fees0";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Release";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "beneficiary";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "fees0";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "UpdateBeneficiary";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: false;
        readonly internalType: "PoolId";
    }, {
        readonly name: "oldBeneficiary";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }, {
        readonly name: "newBeneficiary";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "error";
    readonly name: "CallerNotBeneficiary";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidNewBeneficiary";
    readonly inputs: readonly [];
}, {
    readonly type: "function";
    readonly name: "INITIALIZER";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "claimAirlockOwnerFees";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "fees";
        readonly type: "int256";
        readonly internalType: "BalanceDelta";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getFeeDistributionInfo";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "assetFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getFeeRoutingMode";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint8";
        readonly internalType: "enum FeeRoutingMode";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getFeeSchedule";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "startingTime";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }, {
        readonly name: "startFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "endFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "lastFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "durationSeconds";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getHookFees";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "beneficiaryFees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "beneficiaryFees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "airlockOwnerFees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "airlockOwnerFees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "customFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPoolInfo";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "buybackDst";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPosition";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "tickLower";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "tickUpper";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "liquidity";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "salt";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "poolManager";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract IPoolManager";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "bundler";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "quoter";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract Quoter";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "event";
    readonly name: "AirlockOwnerFeesClaimed";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "airlockOwner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "fees0";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "FeeBeneficiariesSet";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "beneficiaries";
        readonly type: "tuple[]";
        readonly indexed: false;
        readonly internalType: "struct BeneficiaryData[]";
        readonly components: readonly [{
            readonly name: "beneficiary";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "shares";
            readonly type: "uint96";
            readonly internalType: "uint96";
        }];
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "FeeScheduleSet";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "startingTime";
        readonly type: "uint32";
        readonly indexed: false;
        readonly internalType: "uint32";
    }, {
        readonly name: "startFee";
        readonly type: "uint24";
        readonly indexed: false;
        readonly internalType: "uint24";
    }, {
        readonly name: "endFee";
        readonly type: "uint24";
        readonly indexed: false;
        readonly internalType: "uint24";
    }, {
        readonly name: "durationSeconds";
        readonly type: "uint32";
        readonly indexed: false;
        readonly internalType: "uint32";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "FeeUpdated";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "fee";
        readonly type: "uint24";
        readonly indexed: false;
        readonly internalType: "uint24";
    }];
    readonly anonymous: false;
}, {
    readonly type: "function";
    readonly name: "setFeeDistribution";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "assetFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "error";
    readonly name: "FeeBeneficiariesNotConfigured";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "FeeBeneficiariesNotSupportedInDirectBuyback";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "FeeDistributionMustAddUpToWAD";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotAuthorized";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "FeeTooHigh";
    readonly inputs: readonly [{
        readonly name: "fee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }];
}, {
    readonly type: "error";
    readonly name: "InsufficientFeeCurrency";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidDurationSeconds";
    readonly inputs: readonly [{
        readonly name: "durationSeconds";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidFeeRange";
    readonly inputs: readonly [{
        readonly name: "startFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "endFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidProtocolOwnerBeneficiary";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidProtocolOwnerShares";
    readonly inputs: readonly [{
        readonly name: "required";
        readonly type: "uint96";
        readonly internalType: "uint96";
    }, {
        readonly name: "provided";
        readonly type: "uint96";
        readonly internalType: "uint96";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidTotalShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolAlreadyInitialized";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "Reentrancy";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotAirlockOwner";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotInitializer";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "UnorderedBeneficiaries";
    readonly inputs: readonly [];
}];
/** @deprecated Use rehypeDopplerHookInitializerAbi instead. */
declare const rehypeDopplerHookAbi: readonly [{
    readonly type: "function";
    readonly name: "getCumulatedFees0";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getCumulatedFees1";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getLastCumulatedFees0";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getLastCumulatedFees1";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getShares";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "user";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getPoolKey";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "currency0";
        readonly type: "address";
        readonly internalType: "Currency";
    }, {
        readonly name: "currency1";
        readonly type: "address";
        readonly internalType: "Currency";
    }, {
        readonly name: "fee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "tickSpacing";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "hooks";
        readonly type: "address";
        readonly internalType: "contract IHooks";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "updateBeneficiary";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "newBeneficiary";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "event";
    readonly name: "Collect";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "fees0";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "Release";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "beneficiary";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "fees0";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }, {
        readonly name: "fees1";
        readonly type: "uint256";
        readonly indexed: false;
        readonly internalType: "uint256";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "UpdateBeneficiary";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: false;
        readonly internalType: "PoolId";
    }, {
        readonly name: "oldBeneficiary";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }, {
        readonly name: "newBeneficiary";
        readonly type: "address";
        readonly indexed: false;
        readonly internalType: "address";
    }];
    readonly anonymous: false;
}, {
    readonly type: "error";
    readonly name: "CallerNotBeneficiary";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidNewBeneficiary";
    readonly inputs: readonly [];
}, {
    readonly type: "function";
    readonly name: "INITIALIZER";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "claimAirlockOwnerFees";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "fees";
        readonly type: "int256";
        readonly internalType: "BalanceDelta";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getFeeDistributionInfo";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "assetFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getFeeRoutingMode";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint8";
        readonly internalType: "enum FeeRoutingMode";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getFeeSchedule";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "startingTime";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }, {
        readonly name: "startFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "endFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "lastFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "durationSeconds";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getHookFees";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "beneficiaryFees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "beneficiaryFees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "airlockOwnerFees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "airlockOwnerFees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "customFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPoolInfo";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "buybackDst";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPosition";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "tickLower";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "tickUpper";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "liquidity";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "salt";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "poolManager";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract IPoolManager";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "bundler";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "quoter";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract Quoter";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "event";
    readonly name: "AirlockOwnerFeesClaimed";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "airlockOwner";
        readonly type: "address";
        readonly indexed: true;
        readonly internalType: "address";
    }, {
        readonly name: "fees0";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly indexed: false;
        readonly internalType: "uint128";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "FeeBeneficiariesSet";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "beneficiaries";
        readonly type: "tuple[]";
        readonly indexed: false;
        readonly internalType: "struct BeneficiaryData[]";
        readonly components: readonly [{
            readonly name: "beneficiary";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "shares";
            readonly type: "uint96";
            readonly internalType: "uint96";
        }];
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "FeeScheduleSet";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "startingTime";
        readonly type: "uint32";
        readonly indexed: false;
        readonly internalType: "uint32";
    }, {
        readonly name: "startFee";
        readonly type: "uint24";
        readonly indexed: false;
        readonly internalType: "uint24";
    }, {
        readonly name: "endFee";
        readonly type: "uint24";
        readonly indexed: false;
        readonly internalType: "uint24";
    }, {
        readonly name: "durationSeconds";
        readonly type: "uint32";
        readonly indexed: false;
        readonly internalType: "uint32";
    }];
    readonly anonymous: false;
}, {
    readonly type: "event";
    readonly name: "FeeUpdated";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly indexed: true;
        readonly internalType: "PoolId";
    }, {
        readonly name: "fee";
        readonly type: "uint24";
        readonly indexed: false;
        readonly internalType: "uint24";
    }];
    readonly anonymous: false;
}, {
    readonly type: "function";
    readonly name: "setFeeDistribution";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "assetFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "error";
    readonly name: "FeeBeneficiariesNotConfigured";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "FeeBeneficiariesNotSupportedInDirectBuyback";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "FeeDistributionMustAddUpToWAD";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotAuthorized";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "FeeTooHigh";
    readonly inputs: readonly [{
        readonly name: "fee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }];
}, {
    readonly type: "error";
    readonly name: "InsufficientFeeCurrency";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidDurationSeconds";
    readonly inputs: readonly [{
        readonly name: "durationSeconds";
        readonly type: "uint32";
        readonly internalType: "uint32";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidFeeRange";
    readonly inputs: readonly [{
        readonly name: "startFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }, {
        readonly name: "endFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidProtocolOwnerBeneficiary";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidProtocolOwnerShares";
    readonly inputs: readonly [{
        readonly name: "required";
        readonly type: "uint96";
        readonly internalType: "uint96";
    }, {
        readonly name: "provided";
        readonly type: "uint96";
        readonly internalType: "uint96";
    }];
}, {
    readonly type: "error";
    readonly name: "InvalidShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "InvalidTotalShares";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "PoolAlreadyInitialized";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "Reentrancy";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotAirlockOwner";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotInitializer";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "UnorderedBeneficiaries";
    readonly inputs: readonly [];
}];
declare const rehypeDopplerHookMigratorAbi: readonly [{
    readonly type: "function";
    readonly name: "MIGRATOR";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "claimAirlockOwnerFees";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "collectFees";
    readonly inputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "fees";
        readonly type: "int256";
        readonly internalType: "BalanceDelta";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "getFeeDistributionInfo";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "assetFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getFeeRoutingMode";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint8";
        readonly internalType: "enum FeeRoutingMode";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getHookFees";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "fees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "fees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "beneficiaryFees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "beneficiaryFees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "airlockOwnerFees0";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "airlockOwnerFees1";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "customFee";
        readonly type: "uint24";
        readonly internalType: "uint24";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPoolInfo";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "asset";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "numeraire";
        readonly type: "address";
        readonly internalType: "address";
    }, {
        readonly name: "buybackDst";
        readonly type: "address";
        readonly internalType: "address";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "getPosition";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }];
    readonly outputs: readonly [{
        readonly name: "tickLower";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "tickUpper";
        readonly type: "int24";
        readonly internalType: "int24";
    }, {
        readonly name: "liquidity";
        readonly type: "uint128";
        readonly internalType: "uint128";
    }, {
        readonly name: "salt";
        readonly type: "bytes32";
        readonly internalType: "bytes32";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "poolManager";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract IPoolManager";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "quoter";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
        readonly internalType: "contract Quoter";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "setFeeDistribution";
    readonly inputs: readonly [{
        readonly name: "poolId";
        readonly type: "bytes32";
        readonly internalType: "PoolId";
    }, {
        readonly name: "assetFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "assetFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToAssetBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToNumeraireBuybackWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToBeneficiaryWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }, {
        readonly name: "numeraireFeesToLpWad";
        readonly type: "uint256";
        readonly internalType: "uint256";
    }];
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "error";
    readonly name: "FeeDistributionMustAddUpToWAD";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotAirlockOwner";
    readonly inputs: readonly [];
}, {
    readonly type: "error";
    readonly name: "SenderNotAuthorized";
    readonly inputs: readonly [];
}];

declare const VERSION = "1.0.0";

export { ADDRESSES, AirlockCreateReceiptError, type AirlockCreateReceiptErrorCode, type AirlockCreateResult, BASIS_POINTS, type BaseAuctionBuilder, type BeneficiaryData, type BuilderDevBuyInput, type BuilderDevBuyVestingInput, Bundler, type BundlerClaimSimulation, type BundlerVestingPosition, CHAIN_IDS, type ChainAddresses, type CreateDynamicAuctionParams, type CreateMulticurveParams, type CreateOpeningAuctionParams, type CreateParams, type CreateStaticAuctionParams, DAY_SECONDS, DEAD_ADDRESS, DECAY_MAX_START_FEE, DEFAULT_AIRLOCK_BENEFICIARY_SHARES, DEFAULT_AUCTION_DURATION, DEFAULT_EPOCH_LENGTH, DEFAULT_LOCK_DURATION, DEFAULT_MULTICURVE_LOWER_TICKS, DEFAULT_MULTICURVE_MAX_SUPPLY_SHARES, DEFAULT_MULTICURVE_NUM_POSITIONS, DEFAULT_MULTICURVE_UPPER_TICKS, DEFAULT_OPENING_AUCTION_DURATION, DEFAULT_OPENING_AUCTION_FEE, DEFAULT_OPENING_AUCTION_INCENTIVE_SHARE_BPS, DEFAULT_OPENING_AUCTION_MIN_ACCEPTABLE_TICK_TOKEN0, DEFAULT_OPENING_AUCTION_MIN_ACCEPTABLE_TICK_TOKEN1, DEFAULT_OPENING_AUCTION_MIN_LIQUIDITY, DEFAULT_OPENING_AUCTION_SHARE_TO_AUCTION_BPS, DEFAULT_OPENING_DOPPLER_DURATION, DEFAULT_OPENING_DOPPLER_EPOCH_LENGTH, DEFAULT_OPENING_DOPPLER_FEE, DEFAULT_OPENING_DOPPLER_NUM_PD_SLUGS, DEFAULT_OPENING_DOPPLER_TICK_SPACING, DEFAULT_PD_SLUGS, DEFAULT_V3_END_TICK, DEFAULT_V3_FEE, DEFAULT_V3_INITIAL_PROPOSAL_THRESHOLD, DEFAULT_V3_INITIAL_SUPPLY, DEFAULT_V3_INITIAL_VOTING_DELAY, DEFAULT_V3_INITIAL_VOTING_PERIOD, DEFAULT_V3_MAX_SHARE_TO_BE_SOLD, DEFAULT_V3_NUM_POSITIONS, DEFAULT_V3_NUM_TOKENS_TO_SELL, DEFAULT_V3_PRE_MINT, DEFAULT_V3_START_TICK, DEFAULT_V3_VESTING_DURATION, DEFAULT_V3_YEARLY_MINT_RATE, DEFAULT_V4_INITIAL_PROPOSAL_THRESHOLD, DEFAULT_V4_INITIAL_VOTING_DELAY, DEFAULT_V4_INITIAL_VOTING_PERIOD, DEFAULT_V4_YEARLY_MINT_RATE, _default$1 as DERC2080Bytecode, _default$2 as DERC20Bytecode, DOPPLER_FLAGS, DOPPLER_MAX_TICK_SPACING, DYNAMIC_FEE_FLAG, Derc20, Derc20V2, _default$6 as DopplerBytecode, DopplerDN404, _default$4 as DopplerDN404BaseSepoliaBytecode, _default$5 as DopplerDN404Bytecode, DopplerERC20V1, type DopplerERC20V1TokenConfig, DopplerFactory, type DopplerHookMigrationConfig, type DopplerHookMigratorConfig, DopplerSDK, type DopplerSDKConfig, DynamicAuction, DynamicAuctionBuilder, type DynamicAuctionConfig, type DynamicAuctionMarketCapConfig, type DynamicMarketCapRange, Eth, FEE_AMOUNT_MASK, FEE_TIERS, FLAG_MASK, type FeeTier, type GovernanceLaunchpad, type GovernanceOption, type HookInfo, INT24_MAX, INT24_MIN, LAUNCHPAD_ENABLED_CHAIN_IDS, type LaunchpadEnabledChainId, type LockablePoolState, LockablePoolStatus, type LockableV3InitializerParams, MAX_SQRT_RATIO, MAX_TICK, MIN_SQRT_RATIO, MIN_TICK, type MarketCapConfig, type MarketCapRange, type MarketCapValidationResult, type MigrationConfig, type MigrationEncoder, type ModuleAddressOverrides, MulticurveBuilder, type MulticurveCreateGasEstimate, type MulticurveCreatePrediction, type MulticurveCreateResult, type MulticurveDecayFeeSchedule, type MulticurveDevBuyConfig, type MulticurveDevBuyResult, type MulticurveDevBuyVestingConfig, MulticurveFees, type MulticurveFeesOptions, type MulticurveInitializerConfig, type MulticurveMarketCapCurvesConfig, type MulticurveMarketCapPreset, type MulticurveMarketCapRangeCurve, type MulticurveMaxTickLiquidityParams, type MulticurvePendingFees, type MulticurveFeesOptions as MulticurvePendingFeesOptions, MulticurvePool, type MulticurvePoolState, type MulticurveTokenPendingFeeBreakdown, type MulticurveTokenPendingFees, NO_OP_ENABLED_CHAIN_IDS, type NoOpEnabledChainId, type NormalizedRehypeDopplerHookInitializerConfig, OPENING_AUCTION_FLAGS, OPENING_AUCTION_PHASE_ACTIVE, OPENING_AUCTION_PHASE_CLOSED, OPENING_AUCTION_PHASE_NOT_STARTED, OPENING_AUCTION_PHASE_SETTLED, OPENING_AUCTION_STATUS_ACTIVE, OPENING_AUCTION_STATUS_DOPPLER_ACTIVE, OPENING_AUCTION_STATUS_EXITED, OPENING_AUCTION_STATUS_UNINITIALIZED, OpeningAuction, type OpeningAuctionAuctionSettledEvent, type OpeningAuctionBidArgs, type OpeningAuctionBidConstraints, type OpeningAuctionBidLookupArgs, OpeningAuctionBidManager, type OpeningAuctionBidManagerConfig, type OpeningAuctionBidPlacedEvent, type OpeningAuctionBidPositionInfo, type OpeningAuctionBidQuote, type OpeningAuctionBidSimulationResult, type OpeningAuctionBidStatus, type OpeningAuctionBidValidationResult, type OpeningAuctionBidWithdrawnEvent, OpeningAuctionBuilder, _default$3 as OpeningAuctionBytecode, type OpeningAuctionClaimAllIncentivesPreview, type OpeningAuctionClaimAllIncentivesResult, type OpeningAuctionClaimIncentivesSimulationResult, type OpeningAuctionCompleteResult, type OpeningAuctionConfig, type OpeningAuctionCreateResult, type OpeningAuctionDopplerConfig, type OpeningAuctionEstimatedClearingTickUpdatedEvent, type OpeningAuctionIncentiveData, type OpeningAuctionIncentivesClaimedEvent, OpeningAuctionLifecycle, type OpeningAuctionModifyLiquidityParams, type OpeningAuctionModifyLiquiditySimulationResult, type OpeningAuctionModuleAddressOverrides, type OpeningAuctionMoveBidArgs, type OpeningAuctionMoveBidResult, type OpeningAuctionMoveBidSimulationResult, type OpeningAuctionOwnerBidInfo, type OpeningAuctionOwnerBidStatus, OpeningAuctionPhase, type OpeningAuctionPhaseChangedEvent, type OpeningAuctionPosition, OpeningAuctionPositionManager, type OpeningAuctionQuoteFromTokenAmountArgs, type OpeningAuctionQuoteFromTokenAmountResult, type OpeningAuctionSettlementData, type OpeningAuctionState, OpeningAuctionStatus, type OpeningAuctionWatchBidPlacedOptions, type OpeningAuctionWatchBidStatusOptions, type OpeningAuctionWatchBidWithdrawnOptions, type OpeningAuctionWatchEstimatedClearingTickOptions, type OpeningAuctionWatchIncentivesClaimedOptions, type OpeningAuctionWatchPhaseChangeOptions, type OpeningAuctionWatchSettlementOptions, type OpeningAuctionWithdrawFullBidArgs, type OpeningAuctionWithdrawFullBidResult, type OpeningAuctionWithdrawFullBidSimulationResult, type ParseAirlockCreateReceiptParams, type PoolInfo, type PrepareCreateMulticurveOptions, type PreparedCreateTransactionClient, type PreparedMulticurveCreate, type PreparedMulticurveDevBuy, type PreparedMulticurveIdentity, type PreparedMulticurveTransaction, type ProceedsSplitConfig, Q96, type QuoteResult, Quoter, RehypeDopplerHook, type RehypeDopplerHookConfig, RehypeDopplerHookInitializer, type RehypeDopplerHookInitializerConfig, RehypeDopplerHookMigrator, type RehypeDopplerHookMigratorConfig, type RehypeFeeDistributionInfo, RehypeFeeRoutingMode, type RehypePendingFees, type ResolvedOpeningAuctionDopplerConfig, SECONDS_PER_DAY, SECONDS_PER_YEAR, SUPPORTED_CHAIN_IDS, type SaleConfig, type SimulatedMulticurveCreate, _default as StateViewBytecode, StaticAuction, StaticAuctionBuilder, type StaticAuctionMarketCapConfig, type StaticPoolConfig, type StreamableFeesConfig, type SupportedChain, type SupportedChainId, type SupportedChainKey, type SupportedPublicClient, TICK_SPACINGS, type TokenAddressHookConfig, type TokenAddressMiningParams, type TokenAddressMiningResult, type TokenConfig, type TokenVariant, TopUpDistributor, type TopUpParams, type TopUpSimulationResult, type TopUpTransaction, type UniswapV2MigrationConfig, type UniswapV2SplitMigrationConfig, type UniswapV4MigrationConfig, type UniswapV4SplitMigrationConfig, V3_FEE_TIERS, type V4PoolKey, V4_MAX_FEE, VALID_FEE_TIERS, VERSION, type VerifiedMulticurveCreate, type VestingAllocationConfig, type VestingConfig, type VestingScheduleConfig, WAD, ZERO_ADDRESS, airlockAbi, applyTickOffsets, bundlerAbi, calculateFDV, calculateGamma, calculateMarketCap, calculateTickRange, calculateTokensToSell, computeOptimalGamma, computePoolId, createAirlockBeneficiary, decayMulticurveInitializerHookAbi, decodeBalanceDelta, derc20Abi, derc20V2Abi, dopplerDN404Abi, dopplerERC20V1Abi, dopplerHookAbi, dopplerHookInitializerAbi, dopplerLensAbi, encodeRehypeDopplerHookInitializerData, encodeRehypeDopplerHookMigratorCalldata, estimatePriceAtEpoch, estimateSlippage, feeClaimsInitializerAbi, feesManagerAbi, formatTickAsPrice, getAddresses, getAirlockBeneficiary, getAirlockOwner, getAmount0ForLiquidity, getAmount1ForLiquidity, getLiquidityForAmount0, getLiquidityForAmount1, getMaxLiquiditySafeMulticurveTickUpper, getMaxTickRounded, getNearestUsableTick, getSqrtRatioAtTick, getTickAtSqrtRatio, isLaunchpadEnabledChain, isNoOpEnabledChain, isSupportedChainId, isToken0Expected, isToken1, lockableUniswapV3InitializerAbi, marketCapToTickForMulticurve, marketCapToTicksForDynamicAuction, marketCapToTicksForMulticurve, marketCapToTicksForStaticAuction, marketCapToTokenPrice, mineTokenAddress, normalizeBeneficiaries, normalizePoolKey, normalizeRehypeDopplerHookInitializerConfig, openingAuctionAbi, openingAuctionInitializerAbi, openingAuctionPositionManagerAbi, parseAirlockCreateReceipt, poolManagerAbi, priceToSqrtPriceX96, priceToTick, quoterV2Abi, ratioToTick, rehypeDopplerHookAbi, rehypeDopplerHookInitializerAbi, rehypeDopplerHookMigratorAbi, resolveGasEstimate, sortBeneficiaries, sqrtPriceX96ToPrice, streamableFeesLockerAbi, streamableFeesLockerV2Abi, tickToMarketCap, tickToPrice, tokenPriceToRatio, topUpDistributorAbi, uniswapV2Router02Abi, uniswapV3InitializerAbi, uniswapV3PoolAbi, uniswapV4InitializerAbi, v2MigratorAbi, v3MigratorAbi, v4MigratorAbi, v4MulticurveInitializerAbi, v4MulticurveMigratorAbi, v4QuoterAbi, validateMarketCapParameters, verifyPreparedCreateExecution, verifyPreparedCreateReceipt, weth9Abi };