import { type Address, type Hex } from 'viem';
import type { AuctionParameters, AuctionStepInput, Distribution, LiquidityAllocationBracket, MigratorParameters, PositionDefinition, Split, Uerc20Metadata } from './types';
/** The `MigratorParameters` tuple param — exported because the initializer salt hashes over it. */
export declare const MIGRATOR_PARAMETERS_PARAM: {
    readonly name: "migratorParameters";
    readonly type: "tuple";
    readonly components: readonly [{
        readonly name: "token";
        readonly type: "address";
    }, {
        readonly name: "currency";
        readonly type: "address";
    }, {
        readonly name: "migrationBlock";
        readonly type: "uint64";
    }, {
        readonly name: "reservedTokenAmountForLP";
        readonly type: "uint128";
    }, {
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly name: "positionRecipient";
        readonly type: "address";
    }, {
        readonly name: "poolParameters";
        readonly type: "tuple";
        readonly components: readonly [{
            readonly name: "fee";
            readonly type: "uint24";
        }, {
            readonly name: "tickSpacing";
            readonly type: "int24";
        }, {
            readonly name: "hook";
            readonly type: "address";
        }];
    }, {
        readonly name: "positionDefinitions";
        readonly type: "bytes";
    }, {
        readonly name: "lpAllocationSchedule";
        readonly type: "bytes";
    }];
};
/** `abi.encode(PositionDefinition[])` — the `MigratorParameters.positionDefinitions` field. */
export declare function encodePositionDefinitions(definitions: PositionDefinition[]): Hex;
/** `abi.encode(LiquidityAllocationBracket[])` — the `MigratorParameters.lpAllocationSchedule` field. */
export declare function encodeLpAllocationSchedule(brackets: LiquidityAllocationBracket[]): Hex;
/** `abi.encode(AuctionParameters)` — the inner `auctionParams` bytes the CCA factory decodes. */
export declare function encodeAuctionParams(params: AuctionParameters): Hex;
/**
 * `abi.encode(MigratorParameters, bytes auctionParams)` — the strategy's `configData`.
 * `positionDefinitions` / `lpAllocationSchedule` inside `migrator` must already be encoded bytes
 * (use {@link encodePositionDefinitions} / {@link encodeLpAllocationSchedule}).
 */
export declare function encodeConfigData(migrator: MigratorParameters, auctionParams: Hex): Hex;
/** `abi.encode(Split[])` — the TokenSplitter strategy's `configData`. */
export declare function encodeTokenSplitterConfig(splits: Split[]): Hex;
/**
 * `abi.encode(InstantLaunchConfig)` — the InstantLaunchStrategy's `configData` (see `instantLaunch`).
 * A single-member struct today: the LP-fee beneficiary. Mandatory on every strategy instance,
 * including the fees-off one (where the beneficiary goes unused).
 */
export declare function encodeInstantLaunchConfig(config: {
    feeBeneficiary: Address;
}): Hex;
/**
 * Packs the auction emission schedule into the CCA's tight byte format: one 8-byte word per step =
 * `bytes3(mps) ‖ bytes5(blockDelta)`, where `blockDelta = endBlock - startBlock`. See
 * continuous-clearing-auction `StepLib.sol`.
 */
export declare function encodeAuctionSteps(steps: AuctionStepInput[]): Hex;
/**
 * `abi.encode(Uerc20Metadata)` for the UERC20Factory `tokenData` arg. The USUPERC20Factory variant
 * prepends `(uint256 homeChainId, address creator)` — use {@link encodeSuperchainTokenData}.
 */
export declare function encodeTokenData(metadata: Uerc20Metadata): Hex;
export declare function encodeSuperchainTokenData(homeChainId: bigint, creator: Address, metadata: Uerc20Metadata): Hex;
export interface CreateTokenArgs {
    factory: Address;
    name: string;
    symbol: string;
    decimals: number;
    initialSupply: bigint;
    recipient: Address;
    tokenData: Hex;
}
export declare function encodeCreateToken(args: CreateTokenArgs): Hex;
export declare function encodeDistributeToken(token: Address, distribution: Distribution, salt: Hex): Hex;
export declare function encodeDepositToken(token: Address, amount: bigint): Hex;
/** Wraps a list of launcher subcalls into a single `multicall([...])`. */
export declare function encodeMulticall(calls: Hex[]): Hex;
/**
 * ERC20 `approve(spender, amount)` — used to approve Permit2. Defaults to the canonical infinite
 * approval `uint256.max`. Do NOT default to `uint160.max`: UNI/COMP-style governance tokens store
 * allowances as uint96 and revert any amount above 96 bits UNLESS it is exactly `uint256.max`, which
 * they special-case as infinite. (Permit2's own allowance is uint160 — see {@link encodePermit2Approve}.)
 */
export declare function encodeErc20Approve(spender: Address, amount?: bigint): Hex;
/**
 * `ContinuousClearingAuction.sweepUnsoldTokens()` — the creator's token recovery. Callable only by
 * the auction's `tokensRecipient()`, only after `endBlock`, and only once. On a failed
 * (non-graduated) auction it returns the full deposited supply; on a graduated one, the unsold
 * remainder.
 */
export declare function encodeSweepUnsoldTokens(): Hex;
/**
 * `LBPStrategy.migrate(initializer)` — the permissionless success-path migration for the strategy's
 * auction at `auctionAddress`. Sweeps the raised currency and seeds the v4 pool; reverts until the
 * auction is finalized & graduated and `migrationBlock` has passed.
 */
export declare function encodeMigrate(auctionAddress: Address): Hex;
/** Permit2 on-chain allowance `approve(token, spender, amount, expiration)`. */
export declare function encodePermit2Approve(token: Address, spender: Address, amount?: bigint, expiration?: number): Hex;