import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from 'ethers';
import type { FunctionFragment, Result, EventFragment } from '@ethersproject/abi';
import type { Listener, Provider } from '@ethersproject/providers';
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from './common';
export interface AcrossHubPoolV2Interface extends utils.Interface {
    functions: {
        'addLiquidity(address,uint256)': FunctionFragment;
        'bondAmount()': FunctionFragment;
        'bondToken()': FunctionFragment;
        'claimProtocolFeesCaptured(address)': FunctionFragment;
        'crossChainContracts(uint256)': FunctionFragment;
        'disableL1TokenForLiquidityProvision(address)': FunctionFragment;
        'disputeRootBundle()': FunctionFragment;
        'emergencyDeleteProposal()': FunctionFragment;
        'enableL1TokenForLiquidityProvision(address)': FunctionFragment;
        'exchangeRateCurrent(address)': FunctionFragment;
        'executeRootBundle(uint256,uint256,uint256[],int256[],int256[],uint8,address[],bytes32[])': FunctionFragment;
        'finder()': FunctionFragment;
        'getCurrentTime()': FunctionFragment;
        'haircutReserves(address,int256)': FunctionFragment;
        'identifier()': FunctionFragment;
        'liquidityUtilizationCurrent(address)': FunctionFragment;
        'liquidityUtilizationPostRelay(address,uint256)': FunctionFragment;
        'liveness()': FunctionFragment;
        'loadEthForL2Calls()': FunctionFragment;
        'lpFeeRatePerSecond()': FunctionFragment;
        'lpTokenFactory()': FunctionFragment;
        'multicall(bytes[])': FunctionFragment;
        'owner()': FunctionFragment;
        'paused()': FunctionFragment;
        'poolRebalanceRoute(uint256,address)': FunctionFragment;
        'pooledTokens(address)': FunctionFragment;
        'proposeRootBundle(uint256[],uint8,bytes32,bytes32,bytes32)': FunctionFragment;
        'protocolFeeCaptureAddress()': FunctionFragment;
        'protocolFeeCapturePct()': FunctionFragment;
        'relaySpokePoolAdminFunction(uint256,bytes)': FunctionFragment;
        'removeLiquidity(address,uint256,bool)': FunctionFragment;
        'renounceOwnership()': FunctionFragment;
        'rootBundleProposal()': FunctionFragment;
        'setBond(address,uint256)': FunctionFragment;
        'setCrossChainContracts(uint256,address,address)': FunctionFragment;
        'setCurrentTime(uint256)': FunctionFragment;
        'setDepositRoute(uint256,uint256,address,bool)': FunctionFragment;
        'setIdentifier(bytes32)': FunctionFragment;
        'setLiveness(uint32)': FunctionFragment;
        'setPaused(bool)': FunctionFragment;
        'setPoolRebalanceRoute(uint256,address,address)': FunctionFragment;
        'setProtocolFeeCapture(address,uint256)': FunctionFragment;
        'sync(address)': FunctionFragment;
        'timerAddress()': FunctionFragment;
        'transferOwnership(address)': FunctionFragment;
        'unclaimedAccumulatedProtocolFees(address)': FunctionFragment;
        'weth()': FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: 'addLiquidity' | 'bondAmount' | 'bondToken' | 'claimProtocolFeesCaptured' | 'crossChainContracts' | 'disableL1TokenForLiquidityProvision' | 'disputeRootBundle' | 'emergencyDeleteProposal' | 'enableL1TokenForLiquidityProvision' | 'exchangeRateCurrent' | 'executeRootBundle' | 'finder' | 'getCurrentTime' | 'haircutReserves' | 'identifier' | 'liquidityUtilizationCurrent' | 'liquidityUtilizationPostRelay' | 'liveness' | 'loadEthForL2Calls' | 'lpFeeRatePerSecond' | 'lpTokenFactory' | 'multicall' | 'owner' | 'paused' | 'poolRebalanceRoute' | 'pooledTokens' | 'proposeRootBundle' | 'protocolFeeCaptureAddress' | 'protocolFeeCapturePct' | 'relaySpokePoolAdminFunction' | 'removeLiquidity' | 'renounceOwnership' | 'rootBundleProposal' | 'setBond' | 'setCrossChainContracts' | 'setCurrentTime' | 'setDepositRoute' | 'setIdentifier' | 'setLiveness' | 'setPaused' | 'setPoolRebalanceRoute' | 'setProtocolFeeCapture' | 'sync' | 'timerAddress' | 'transferOwnership' | 'unclaimedAccumulatedProtocolFees' | 'weth'): FunctionFragment;
    encodeFunctionData(functionFragment: 'addLiquidity', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'bondAmount', values?: undefined): string;
    encodeFunctionData(functionFragment: 'bondToken', values?: undefined): string;
    encodeFunctionData(functionFragment: 'claimProtocolFeesCaptured', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'crossChainContracts', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'disableL1TokenForLiquidityProvision', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'disputeRootBundle', values?: undefined): string;
    encodeFunctionData(functionFragment: 'emergencyDeleteProposal', values?: undefined): string;
    encodeFunctionData(functionFragment: 'enableL1TokenForLiquidityProvision', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'exchangeRateCurrent', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'executeRootBundle', values: [
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>[],
        PromiseOrValue<BigNumberish>[],
        PromiseOrValue<BigNumberish>[],
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>[],
        PromiseOrValue<BytesLike>[]
    ]): string;
    encodeFunctionData(functionFragment: 'finder', values?: undefined): string;
    encodeFunctionData(functionFragment: 'getCurrentTime', values?: undefined): string;
    encodeFunctionData(functionFragment: 'haircutReserves', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'identifier', values?: undefined): string;
    encodeFunctionData(functionFragment: 'liquidityUtilizationCurrent', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'liquidityUtilizationPostRelay', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'liveness', values?: undefined): string;
    encodeFunctionData(functionFragment: 'loadEthForL2Calls', values?: undefined): string;
    encodeFunctionData(functionFragment: 'lpFeeRatePerSecond', values?: undefined): string;
    encodeFunctionData(functionFragment: 'lpTokenFactory', values?: undefined): string;
    encodeFunctionData(functionFragment: 'multicall', values: [PromiseOrValue<BytesLike>[]]): string;
    encodeFunctionData(functionFragment: 'owner', values?: undefined): string;
    encodeFunctionData(functionFragment: 'paused', values?: undefined): string;
    encodeFunctionData(functionFragment: 'poolRebalanceRoute', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'pooledTokens', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'proposeRootBundle', values: [
        PromiseOrValue<BigNumberish>[],
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<BytesLike>
    ]): string;
    encodeFunctionData(functionFragment: 'protocolFeeCaptureAddress', values?: undefined): string;
    encodeFunctionData(functionFragment: 'protocolFeeCapturePct', values?: undefined): string;
    encodeFunctionData(functionFragment: 'relaySpokePoolAdminFunction', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: 'removeLiquidity', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string;
    encodeFunctionData(functionFragment: 'rootBundleProposal', values?: undefined): string;
    encodeFunctionData(functionFragment: 'setBond', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setCrossChainContracts', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setCurrentTime', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setDepositRoute', values: [
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>,
        PromiseOrValue<boolean>
    ]): string;
    encodeFunctionData(functionFragment: 'setIdentifier', values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: 'setLiveness', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setPaused', values: [PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: 'setPoolRebalanceRoute', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setProtocolFeeCapture', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'sync', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'timerAddress', values?: undefined): string;
    encodeFunctionData(functionFragment: 'transferOwnership', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'unclaimedAccumulatedProtocolFees', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'weth', values?: undefined): string;
    decodeFunctionResult(functionFragment: 'addLiquidity', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'bondAmount', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'bondToken', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'claimProtocolFeesCaptured', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'crossChainContracts', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'disableL1TokenForLiquidityProvision', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'disputeRootBundle', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'emergencyDeleteProposal', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'enableL1TokenForLiquidityProvision', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'exchangeRateCurrent', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'executeRootBundle', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'finder', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getCurrentTime', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'haircutReserves', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'identifier', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'liquidityUtilizationCurrent', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'liquidityUtilizationPostRelay', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'liveness', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'loadEthForL2Calls', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lpFeeRatePerSecond', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lpTokenFactory', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'multicall', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'paused', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'poolRebalanceRoute', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'pooledTokens', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'proposeRootBundle', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'protocolFeeCaptureAddress', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'protocolFeeCapturePct', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'relaySpokePoolAdminFunction', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'removeLiquidity', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'rootBundleProposal', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setBond', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setCrossChainContracts', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setCurrentTime', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setDepositRoute', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setIdentifier', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setLiveness', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setPaused', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setPoolRebalanceRoute', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setProtocolFeeCapture', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'sync', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'timerAddress', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'unclaimedAccumulatedProtocolFees', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'weth', data: BytesLike): Result;
    events: {
        'BondSet(address,uint256)': EventFragment;
        'CrossChainContractsSet(uint256,address,address)': EventFragment;
        'EmergencyRootBundleDeleted(bytes32,bytes32,bytes32,address)': EventFragment;
        'IdentifierSet(bytes32)': EventFragment;
        'L1TokenEnabledForLiquidityProvision(address,address)': EventFragment;
        'L2TokenDisabledForLiquidityProvision(address,address)': EventFragment;
        'LiquidityAdded(address,uint256,uint256,address)': EventFragment;
        'LiquidityRemoved(address,uint256,uint256,address)': EventFragment;
        'LivenessSet(uint256)': EventFragment;
        'OwnershipTransferred(address,address)': EventFragment;
        'Paused(bool)': EventFragment;
        'ProposeRootBundle(uint32,uint8,uint256[],bytes32,bytes32,bytes32,address)': EventFragment;
        'ProtocolFeeCaptureSet(address,uint256)': EventFragment;
        'ProtocolFeesCapturedClaimed(address,uint256)': EventFragment;
        'RootBundleCanceled(address,uint256)': EventFragment;
        'RootBundleDisputed(address,uint256)': EventFragment;
        'RootBundleExecuted(uint256,uint256,uint256,address[],uint256[],int256[],int256[],address)': EventFragment;
        'SetEnableDepositRoute(uint256,uint256,address,bool)': EventFragment;
        'SetPoolRebalanceRoute(uint256,address,address)': EventFragment;
        'SpokePoolAdminFunctionTriggered(uint256,bytes)': EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: 'BondSet'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'CrossChainContractsSet'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'EmergencyRootBundleDeleted'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'IdentifierSet'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'L1TokenEnabledForLiquidityProvision'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'L2TokenDisabledForLiquidityProvision'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LiquidityAdded'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LiquidityRemoved'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LivenessSet'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'ProposeRootBundle'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'ProtocolFeeCaptureSet'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'ProtocolFeesCapturedClaimed'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'RootBundleCanceled'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'RootBundleDisputed'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'RootBundleExecuted'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetEnableDepositRoute'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetPoolRebalanceRoute'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SpokePoolAdminFunctionTriggered'): EventFragment;
}
export interface BondSetEventObject {
    newBondToken: string;
    newBondAmount: BigNumber;
}
export declare type BondSetEvent = TypedEvent<[string, BigNumber], BondSetEventObject>;
export declare type BondSetEventFilter = TypedEventFilter<BondSetEvent>;
export interface CrossChainContractsSetEventObject {
    l2ChainId: BigNumber;
    adapter: string;
    spokePool: string;
}
export declare type CrossChainContractsSetEvent = TypedEvent<[BigNumber, string, string], CrossChainContractsSetEventObject>;
export declare type CrossChainContractsSetEventFilter = TypedEventFilter<CrossChainContractsSetEvent>;
export interface EmergencyRootBundleDeletedEventObject {
    poolRebalanceRoot: string;
    relayerRefundRoot: string;
    slowRelayRoot: string;
    proposer: string;
}
export declare type EmergencyRootBundleDeletedEvent = TypedEvent<[
    string,
    string,
    string,
    string
], EmergencyRootBundleDeletedEventObject>;
export declare type EmergencyRootBundleDeletedEventFilter = TypedEventFilter<EmergencyRootBundleDeletedEvent>;
export interface IdentifierSetEventObject {
    newIdentifier: string;
}
export declare type IdentifierSetEvent = TypedEvent<[string], IdentifierSetEventObject>;
export declare type IdentifierSetEventFilter = TypedEventFilter<IdentifierSetEvent>;
export interface L1TokenEnabledForLiquidityProvisionEventObject {
    l1Token: string;
    lpToken: string;
}
export declare type L1TokenEnabledForLiquidityProvisionEvent = TypedEvent<[
    string,
    string
], L1TokenEnabledForLiquidityProvisionEventObject>;
export declare type L1TokenEnabledForLiquidityProvisionEventFilter = TypedEventFilter<L1TokenEnabledForLiquidityProvisionEvent>;
export interface L2TokenDisabledForLiquidityProvisionEventObject {
    l1Token: string;
    lpToken: string;
}
export declare type L2TokenDisabledForLiquidityProvisionEvent = TypedEvent<[
    string,
    string
], L2TokenDisabledForLiquidityProvisionEventObject>;
export declare type L2TokenDisabledForLiquidityProvisionEventFilter = TypedEventFilter<L2TokenDisabledForLiquidityProvisionEvent>;
export interface LiquidityAddedEventObject {
    l1Token: string;
    amount: BigNumber;
    lpTokensMinted: BigNumber;
    liquidityProvider: string;
}
export declare type LiquidityAddedEvent = TypedEvent<[string, BigNumber, BigNumber, string], LiquidityAddedEventObject>;
export declare type LiquidityAddedEventFilter = TypedEventFilter<LiquidityAddedEvent>;
export interface LiquidityRemovedEventObject {
    l1Token: string;
    amount: BigNumber;
    lpTokensBurnt: BigNumber;
    liquidityProvider: string;
}
export declare type LiquidityRemovedEvent = TypedEvent<[string, BigNumber, BigNumber, string], LiquidityRemovedEventObject>;
export declare type LiquidityRemovedEventFilter = TypedEventFilter<LiquidityRemovedEvent>;
export interface LivenessSetEventObject {
    newLiveness: BigNumber;
}
export declare type LivenessSetEvent = TypedEvent<[BigNumber], LivenessSetEventObject>;
export declare type LivenessSetEventFilter = TypedEventFilter<LivenessSetEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export declare type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>;
export declare type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface PausedEventObject {
    isPaused: boolean;
}
export declare type PausedEvent = TypedEvent<[boolean], PausedEventObject>;
export declare type PausedEventFilter = TypedEventFilter<PausedEvent>;
export interface ProposeRootBundleEventObject {
    challengePeriodEndTimestamp: number;
    poolRebalanceLeafCount: number;
    bundleEvaluationBlockNumbers: BigNumber[];
    poolRebalanceRoot: string;
    relayerRefundRoot: string;
    slowRelayRoot: string;
    proposer: string;
}
export declare type ProposeRootBundleEvent = TypedEvent<[
    number,
    number,
    BigNumber[],
    string,
    string,
    string,
    string
], ProposeRootBundleEventObject>;
export declare type ProposeRootBundleEventFilter = TypedEventFilter<ProposeRootBundleEvent>;
export interface ProtocolFeeCaptureSetEventObject {
    newProtocolFeeCaptureAddress: string;
    newProtocolFeeCapturePct: BigNumber;
}
export declare type ProtocolFeeCaptureSetEvent = TypedEvent<[string, BigNumber], ProtocolFeeCaptureSetEventObject>;
export declare type ProtocolFeeCaptureSetEventFilter = TypedEventFilter<ProtocolFeeCaptureSetEvent>;
export interface ProtocolFeesCapturedClaimedEventObject {
    l1Token: string;
    accumulatedFees: BigNumber;
}
export declare type ProtocolFeesCapturedClaimedEvent = TypedEvent<[string, BigNumber], ProtocolFeesCapturedClaimedEventObject>;
export declare type ProtocolFeesCapturedClaimedEventFilter = TypedEventFilter<ProtocolFeesCapturedClaimedEvent>;
export interface RootBundleCanceledEventObject {
    disputer: string;
    requestTime: BigNumber;
}
export declare type RootBundleCanceledEvent = TypedEvent<[string, BigNumber], RootBundleCanceledEventObject>;
export declare type RootBundleCanceledEventFilter = TypedEventFilter<RootBundleCanceledEvent>;
export interface RootBundleDisputedEventObject {
    disputer: string;
    requestTime: BigNumber;
}
export declare type RootBundleDisputedEvent = TypedEvent<[string, BigNumber], RootBundleDisputedEventObject>;
export declare type RootBundleDisputedEventFilter = TypedEventFilter<RootBundleDisputedEvent>;
export interface RootBundleExecutedEventObject {
    groupIndex: BigNumber;
    leafId: BigNumber;
    chainId: BigNumber;
    l1Tokens: string[];
    bundleLpFees: BigNumber[];
    netSendAmounts: BigNumber[];
    runningBalances: BigNumber[];
    caller: string;
}
export declare type RootBundleExecutedEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber,
    string[],
    BigNumber[],
    BigNumber[],
    BigNumber[],
    string
], RootBundleExecutedEventObject>;
export declare type RootBundleExecutedEventFilter = TypedEventFilter<RootBundleExecutedEvent>;
export interface SetEnableDepositRouteEventObject {
    originChainId: BigNumber;
    destinationChainId: BigNumber;
    originToken: string;
    depositsEnabled: boolean;
}
export declare type SetEnableDepositRouteEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    string,
    boolean
], SetEnableDepositRouteEventObject>;
export declare type SetEnableDepositRouteEventFilter = TypedEventFilter<SetEnableDepositRouteEvent>;
export interface SetPoolRebalanceRouteEventObject {
    destinationChainId: BigNumber;
    l1Token: string;
    destinationToken: string;
}
export declare type SetPoolRebalanceRouteEvent = TypedEvent<[BigNumber, string, string], SetPoolRebalanceRouteEventObject>;
export declare type SetPoolRebalanceRouteEventFilter = TypedEventFilter<SetPoolRebalanceRouteEvent>;
export interface SpokePoolAdminFunctionTriggeredEventObject {
    chainId: BigNumber;
    message: string;
}
export declare type SpokePoolAdminFunctionTriggeredEvent = TypedEvent<[
    BigNumber,
    string
], SpokePoolAdminFunctionTriggeredEventObject>;
export declare type SpokePoolAdminFunctionTriggeredEventFilter = TypedEventFilter<SpokePoolAdminFunctionTriggeredEvent>;
export interface AcrossHubPoolV2 extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: AcrossHubPoolV2Interface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        addLiquidity(l1Token: PromiseOrValue<string>, l1TokenAmount: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        bondAmount(overrides?: CallOverrides): Promise<[BigNumber]>;
        bondToken(overrides?: CallOverrides): Promise<[string]>;
        claimProtocolFeesCaptured(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        crossChainContracts(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string, string] & {
            adapter: string;
            spokePool: string;
        }>;
        disableL1TokenForLiquidityProvision(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        disputeRootBundle(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        emergencyDeleteProposal(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        enableL1TokenForLiquidityProvision(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        exchangeRateCurrent(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        executeRootBundle(chainId: PromiseOrValue<BigNumberish>, groupIndex: PromiseOrValue<BigNumberish>, bundleLpFees: PromiseOrValue<BigNumberish>[], netSendAmounts: PromiseOrValue<BigNumberish>[], runningBalances: PromiseOrValue<BigNumberish>[], leafId: PromiseOrValue<BigNumberish>, l1Tokens: PromiseOrValue<string>[], proof: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        finder(overrides?: CallOverrides): Promise<[string]>;
        getCurrentTime(overrides?: CallOverrides): Promise<[BigNumber]>;
        haircutReserves(l1Token: PromiseOrValue<string>, haircutAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        identifier(overrides?: CallOverrides): Promise<[string]>;
        liquidityUtilizationCurrent(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        liquidityUtilizationPostRelay(l1Token: PromiseOrValue<string>, relayedAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        liveness(overrides?: CallOverrides): Promise<[number]>;
        loadEthForL2Calls(overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        lpFeeRatePerSecond(overrides?: CallOverrides): Promise<[BigNumber]>;
        lpTokenFactory(overrides?: CallOverrides): Promise<[string]>;
        multicall(data: PromiseOrValue<BytesLike>[], overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        paused(overrides?: CallOverrides): Promise<[boolean]>;
        poolRebalanceRoute(destinationChainId: PromiseOrValue<BigNumberish>, l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string] & {
            destinationToken: string;
        }>;
        pooledTokens(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            string,
            boolean,
            number,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            lpToken: string;
            isEnabled: boolean;
            lastLpFeeUpdate: number;
            utilizedReserves: BigNumber;
            liquidReserves: BigNumber;
            undistributedLpFees: BigNumber;
        }>;
        proposeRootBundle(bundleEvaluationBlockNumbers: PromiseOrValue<BigNumberish>[], poolRebalanceLeafCount: PromiseOrValue<BigNumberish>, poolRebalanceRoot: PromiseOrValue<BytesLike>, relayerRefundRoot: PromiseOrValue<BytesLike>, slowRelayRoot: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        protocolFeeCaptureAddress(overrides?: CallOverrides): Promise<[string]>;
        protocolFeeCapturePct(overrides?: CallOverrides): Promise<[BigNumber]>;
        relaySpokePoolAdminFunction(chainId: PromiseOrValue<BigNumberish>, functionData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        removeLiquidity(l1Token: PromiseOrValue<string>, lpTokenAmount: PromiseOrValue<BigNumberish>, sendEth: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        rootBundleProposal(overrides?: CallOverrides): Promise<[
            string,
            string,
            string,
            BigNumber,
            string,
            number,
            number
        ] & {
            poolRebalanceRoot: string;
            relayerRefundRoot: string;
            slowRelayRoot: string;
            claimedBitMap: BigNumber;
            proposer: string;
            unclaimedPoolRebalanceLeafCount: number;
            challengePeriodEndTimestamp: number;
        }>;
        setBond(newBondToken: PromiseOrValue<string>, newBondAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setCrossChainContracts(l2ChainId: PromiseOrValue<BigNumberish>, adapter: PromiseOrValue<string>, spokePool: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setCurrentTime(time: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setDepositRoute(originChainId: PromiseOrValue<BigNumberish>, destinationChainId: PromiseOrValue<BigNumberish>, originToken: PromiseOrValue<string>, depositsEnabled: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setIdentifier(newIdentifier: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setLiveness(newLiveness: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setPaused(pause: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setPoolRebalanceRoute(destinationChainId: PromiseOrValue<BigNumberish>, l1Token: PromiseOrValue<string>, destinationToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setProtocolFeeCapture(newProtocolFeeCaptureAddress: PromiseOrValue<string>, newProtocolFeeCapturePct: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        sync(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        timerAddress(overrides?: CallOverrides): Promise<[string]>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        unclaimedAccumulatedProtocolFees(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        weth(overrides?: CallOverrides): Promise<[string]>;
    };
    addLiquidity(l1Token: PromiseOrValue<string>, l1TokenAmount: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    bondAmount(overrides?: CallOverrides): Promise<BigNumber>;
    bondToken(overrides?: CallOverrides): Promise<string>;
    claimProtocolFeesCaptured(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    crossChainContracts(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string, string] & {
        adapter: string;
        spokePool: string;
    }>;
    disableL1TokenForLiquidityProvision(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    disputeRootBundle(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    emergencyDeleteProposal(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    enableL1TokenForLiquidityProvision(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    exchangeRateCurrent(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    executeRootBundle(chainId: PromiseOrValue<BigNumberish>, groupIndex: PromiseOrValue<BigNumberish>, bundleLpFees: PromiseOrValue<BigNumberish>[], netSendAmounts: PromiseOrValue<BigNumberish>[], runningBalances: PromiseOrValue<BigNumberish>[], leafId: PromiseOrValue<BigNumberish>, l1Tokens: PromiseOrValue<string>[], proof: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    finder(overrides?: CallOverrides): Promise<string>;
    getCurrentTime(overrides?: CallOverrides): Promise<BigNumber>;
    haircutReserves(l1Token: PromiseOrValue<string>, haircutAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    identifier(overrides?: CallOverrides): Promise<string>;
    liquidityUtilizationCurrent(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    liquidityUtilizationPostRelay(l1Token: PromiseOrValue<string>, relayedAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    liveness(overrides?: CallOverrides): Promise<number>;
    loadEthForL2Calls(overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    lpFeeRatePerSecond(overrides?: CallOverrides): Promise<BigNumber>;
    lpTokenFactory(overrides?: CallOverrides): Promise<string>;
    multicall(data: PromiseOrValue<BytesLike>[], overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    owner(overrides?: CallOverrides): Promise<string>;
    paused(overrides?: CallOverrides): Promise<boolean>;
    poolRebalanceRoute(destinationChainId: PromiseOrValue<BigNumberish>, l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
    pooledTokens(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        string,
        boolean,
        number,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        lpToken: string;
        isEnabled: boolean;
        lastLpFeeUpdate: number;
        utilizedReserves: BigNumber;
        liquidReserves: BigNumber;
        undistributedLpFees: BigNumber;
    }>;
    proposeRootBundle(bundleEvaluationBlockNumbers: PromiseOrValue<BigNumberish>[], poolRebalanceLeafCount: PromiseOrValue<BigNumberish>, poolRebalanceRoot: PromiseOrValue<BytesLike>, relayerRefundRoot: PromiseOrValue<BytesLike>, slowRelayRoot: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    protocolFeeCaptureAddress(overrides?: CallOverrides): Promise<string>;
    protocolFeeCapturePct(overrides?: CallOverrides): Promise<BigNumber>;
    relaySpokePoolAdminFunction(chainId: PromiseOrValue<BigNumberish>, functionData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    removeLiquidity(l1Token: PromiseOrValue<string>, lpTokenAmount: PromiseOrValue<BigNumberish>, sendEth: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    renounceOwnership(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    rootBundleProposal(overrides?: CallOverrides): Promise<[
        string,
        string,
        string,
        BigNumber,
        string,
        number,
        number
    ] & {
        poolRebalanceRoot: string;
        relayerRefundRoot: string;
        slowRelayRoot: string;
        claimedBitMap: BigNumber;
        proposer: string;
        unclaimedPoolRebalanceLeafCount: number;
        challengePeriodEndTimestamp: number;
    }>;
    setBond(newBondToken: PromiseOrValue<string>, newBondAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setCrossChainContracts(l2ChainId: PromiseOrValue<BigNumberish>, adapter: PromiseOrValue<string>, spokePool: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setCurrentTime(time: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setDepositRoute(originChainId: PromiseOrValue<BigNumberish>, destinationChainId: PromiseOrValue<BigNumberish>, originToken: PromiseOrValue<string>, depositsEnabled: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setIdentifier(newIdentifier: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setLiveness(newLiveness: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setPaused(pause: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setPoolRebalanceRoute(destinationChainId: PromiseOrValue<BigNumberish>, l1Token: PromiseOrValue<string>, destinationToken: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setProtocolFeeCapture(newProtocolFeeCaptureAddress: PromiseOrValue<string>, newProtocolFeeCapturePct: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    sync(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    timerAddress(overrides?: CallOverrides): Promise<string>;
    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    unclaimedAccumulatedProtocolFees(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    weth(overrides?: CallOverrides): Promise<string>;
    callStatic: {
        addLiquidity(l1Token: PromiseOrValue<string>, l1TokenAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        bondAmount(overrides?: CallOverrides): Promise<BigNumber>;
        bondToken(overrides?: CallOverrides): Promise<string>;
        claimProtocolFeesCaptured(l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        crossChainContracts(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string, string] & {
            adapter: string;
            spokePool: string;
        }>;
        disableL1TokenForLiquidityProvision(l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        disputeRootBundle(overrides?: CallOverrides): Promise<void>;
        emergencyDeleteProposal(overrides?: CallOverrides): Promise<void>;
        enableL1TokenForLiquidityProvision(l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        exchangeRateCurrent(l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        executeRootBundle(chainId: PromiseOrValue<BigNumberish>, groupIndex: PromiseOrValue<BigNumberish>, bundleLpFees: PromiseOrValue<BigNumberish>[], netSendAmounts: PromiseOrValue<BigNumberish>[], runningBalances: PromiseOrValue<BigNumberish>[], leafId: PromiseOrValue<BigNumberish>, l1Tokens: PromiseOrValue<string>[], proof: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<void>;
        finder(overrides?: CallOverrides): Promise<string>;
        getCurrentTime(overrides?: CallOverrides): Promise<BigNumber>;
        haircutReserves(l1Token: PromiseOrValue<string>, haircutAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        identifier(overrides?: CallOverrides): Promise<string>;
        liquidityUtilizationCurrent(l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        liquidityUtilizationPostRelay(l1Token: PromiseOrValue<string>, relayedAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        liveness(overrides?: CallOverrides): Promise<number>;
        loadEthForL2Calls(overrides?: CallOverrides): Promise<void>;
        lpFeeRatePerSecond(overrides?: CallOverrides): Promise<BigNumber>;
        lpTokenFactory(overrides?: CallOverrides): Promise<string>;
        multicall(data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<string[]>;
        owner(overrides?: CallOverrides): Promise<string>;
        paused(overrides?: CallOverrides): Promise<boolean>;
        poolRebalanceRoute(destinationChainId: PromiseOrValue<BigNumberish>, l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
        pooledTokens(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            string,
            boolean,
            number,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            lpToken: string;
            isEnabled: boolean;
            lastLpFeeUpdate: number;
            utilizedReserves: BigNumber;
            liquidReserves: BigNumber;
            undistributedLpFees: BigNumber;
        }>;
        proposeRootBundle(bundleEvaluationBlockNumbers: PromiseOrValue<BigNumberish>[], poolRebalanceLeafCount: PromiseOrValue<BigNumberish>, poolRebalanceRoot: PromiseOrValue<BytesLike>, relayerRefundRoot: PromiseOrValue<BytesLike>, slowRelayRoot: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        protocolFeeCaptureAddress(overrides?: CallOverrides): Promise<string>;
        protocolFeeCapturePct(overrides?: CallOverrides): Promise<BigNumber>;
        relaySpokePoolAdminFunction(chainId: PromiseOrValue<BigNumberish>, functionData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        removeLiquidity(l1Token: PromiseOrValue<string>, lpTokenAmount: PromiseOrValue<BigNumberish>, sendEth: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        rootBundleProposal(overrides?: CallOverrides): Promise<[
            string,
            string,
            string,
            BigNumber,
            string,
            number,
            number
        ] & {
            poolRebalanceRoot: string;
            relayerRefundRoot: string;
            slowRelayRoot: string;
            claimedBitMap: BigNumber;
            proposer: string;
            unclaimedPoolRebalanceLeafCount: number;
            challengePeriodEndTimestamp: number;
        }>;
        setBond(newBondToken: PromiseOrValue<string>, newBondAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setCrossChainContracts(l2ChainId: PromiseOrValue<BigNumberish>, adapter: PromiseOrValue<string>, spokePool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setCurrentTime(time: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setDepositRoute(originChainId: PromiseOrValue<BigNumberish>, destinationChainId: PromiseOrValue<BigNumberish>, originToken: PromiseOrValue<string>, depositsEnabled: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setIdentifier(newIdentifier: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        setLiveness(newLiveness: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setPaused(pause: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setPoolRebalanceRoute(destinationChainId: PromiseOrValue<BigNumberish>, l1Token: PromiseOrValue<string>, destinationToken: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setProtocolFeeCapture(newProtocolFeeCaptureAddress: PromiseOrValue<string>, newProtocolFeeCapturePct: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        sync(l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        timerAddress(overrides?: CallOverrides): Promise<string>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        unclaimedAccumulatedProtocolFees(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        weth(overrides?: CallOverrides): Promise<string>;
    };
    filters: {
        'BondSet(address,uint256)'(newBondToken?: PromiseOrValue<string> | null, newBondAmount?: null): BondSetEventFilter;
        BondSet(newBondToken?: PromiseOrValue<string> | null, newBondAmount?: null): BondSetEventFilter;
        'CrossChainContractsSet(uint256,address,address)'(l2ChainId?: null, adapter?: null, spokePool?: null): CrossChainContractsSetEventFilter;
        CrossChainContractsSet(l2ChainId?: null, adapter?: null, spokePool?: null): CrossChainContractsSetEventFilter;
        'EmergencyRootBundleDeleted(bytes32,bytes32,bytes32,address)'(poolRebalanceRoot?: PromiseOrValue<BytesLike> | null, relayerRefundRoot?: PromiseOrValue<BytesLike> | null, slowRelayRoot?: null, proposer?: PromiseOrValue<string> | null): EmergencyRootBundleDeletedEventFilter;
        EmergencyRootBundleDeleted(poolRebalanceRoot?: PromiseOrValue<BytesLike> | null, relayerRefundRoot?: PromiseOrValue<BytesLike> | null, slowRelayRoot?: null, proposer?: PromiseOrValue<string> | null): EmergencyRootBundleDeletedEventFilter;
        'IdentifierSet(bytes32)'(newIdentifier?: null): IdentifierSetEventFilter;
        IdentifierSet(newIdentifier?: null): IdentifierSetEventFilter;
        'L1TokenEnabledForLiquidityProvision(address,address)'(l1Token?: null, lpToken?: null): L1TokenEnabledForLiquidityProvisionEventFilter;
        L1TokenEnabledForLiquidityProvision(l1Token?: null, lpToken?: null): L1TokenEnabledForLiquidityProvisionEventFilter;
        'L2TokenDisabledForLiquidityProvision(address,address)'(l1Token?: null, lpToken?: null): L2TokenDisabledForLiquidityProvisionEventFilter;
        L2TokenDisabledForLiquidityProvision(l1Token?: null, lpToken?: null): L2TokenDisabledForLiquidityProvisionEventFilter;
        'LiquidityAdded(address,uint256,uint256,address)'(l1Token?: PromiseOrValue<string> | null, amount?: null, lpTokensMinted?: null, liquidityProvider?: PromiseOrValue<string> | null): LiquidityAddedEventFilter;
        LiquidityAdded(l1Token?: PromiseOrValue<string> | null, amount?: null, lpTokensMinted?: null, liquidityProvider?: PromiseOrValue<string> | null): LiquidityAddedEventFilter;
        'LiquidityRemoved(address,uint256,uint256,address)'(l1Token?: PromiseOrValue<string> | null, amount?: null, lpTokensBurnt?: null, liquidityProvider?: PromiseOrValue<string> | null): LiquidityRemovedEventFilter;
        LiquidityRemoved(l1Token?: PromiseOrValue<string> | null, amount?: null, lpTokensBurnt?: null, liquidityProvider?: PromiseOrValue<string> | null): LiquidityRemovedEventFilter;
        'LivenessSet(uint256)'(newLiveness?: null): LivenessSetEventFilter;
        LivenessSet(newLiveness?: null): LivenessSetEventFilter;
        'OwnershipTransferred(address,address)'(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
        'Paused(bool)'(isPaused?: PromiseOrValue<boolean> | null): PausedEventFilter;
        Paused(isPaused?: PromiseOrValue<boolean> | null): PausedEventFilter;
        'ProposeRootBundle(uint32,uint8,uint256[],bytes32,bytes32,bytes32,address)'(challengePeriodEndTimestamp?: null, poolRebalanceLeafCount?: null, bundleEvaluationBlockNumbers?: null, poolRebalanceRoot?: PromiseOrValue<BytesLike> | null, relayerRefundRoot?: PromiseOrValue<BytesLike> | null, slowRelayRoot?: null, proposer?: PromiseOrValue<string> | null): ProposeRootBundleEventFilter;
        ProposeRootBundle(challengePeriodEndTimestamp?: null, poolRebalanceLeafCount?: null, bundleEvaluationBlockNumbers?: null, poolRebalanceRoot?: PromiseOrValue<BytesLike> | null, relayerRefundRoot?: PromiseOrValue<BytesLike> | null, slowRelayRoot?: null, proposer?: PromiseOrValue<string> | null): ProposeRootBundleEventFilter;
        'ProtocolFeeCaptureSet(address,uint256)'(newProtocolFeeCaptureAddress?: PromiseOrValue<string> | null, newProtocolFeeCapturePct?: PromiseOrValue<BigNumberish> | null): ProtocolFeeCaptureSetEventFilter;
        ProtocolFeeCaptureSet(newProtocolFeeCaptureAddress?: PromiseOrValue<string> | null, newProtocolFeeCapturePct?: PromiseOrValue<BigNumberish> | null): ProtocolFeeCaptureSetEventFilter;
        'ProtocolFeesCapturedClaimed(address,uint256)'(l1Token?: PromiseOrValue<string> | null, accumulatedFees?: PromiseOrValue<BigNumberish> | null): ProtocolFeesCapturedClaimedEventFilter;
        ProtocolFeesCapturedClaimed(l1Token?: PromiseOrValue<string> | null, accumulatedFees?: PromiseOrValue<BigNumberish> | null): ProtocolFeesCapturedClaimedEventFilter;
        'RootBundleCanceled(address,uint256)'(disputer?: PromiseOrValue<string> | null, requestTime?: null): RootBundleCanceledEventFilter;
        RootBundleCanceled(disputer?: PromiseOrValue<string> | null, requestTime?: null): RootBundleCanceledEventFilter;
        'RootBundleDisputed(address,uint256)'(disputer?: PromiseOrValue<string> | null, requestTime?: null): RootBundleDisputedEventFilter;
        RootBundleDisputed(disputer?: PromiseOrValue<string> | null, requestTime?: null): RootBundleDisputedEventFilter;
        'RootBundleExecuted(uint256,uint256,uint256,address[],uint256[],int256[],int256[],address)'(groupIndex?: null, leafId?: PromiseOrValue<BigNumberish> | null, chainId?: PromiseOrValue<BigNumberish> | null, l1Tokens?: null, bundleLpFees?: null, netSendAmounts?: null, runningBalances?: null, caller?: PromiseOrValue<string> | null): RootBundleExecutedEventFilter;
        RootBundleExecuted(groupIndex?: null, leafId?: PromiseOrValue<BigNumberish> | null, chainId?: PromiseOrValue<BigNumberish> | null, l1Tokens?: null, bundleLpFees?: null, netSendAmounts?: null, runningBalances?: null, caller?: PromiseOrValue<string> | null): RootBundleExecutedEventFilter;
        'SetEnableDepositRoute(uint256,uint256,address,bool)'(originChainId?: PromiseOrValue<BigNumberish> | null, destinationChainId?: PromiseOrValue<BigNumberish> | null, originToken?: PromiseOrValue<string> | null, depositsEnabled?: null): SetEnableDepositRouteEventFilter;
        SetEnableDepositRoute(originChainId?: PromiseOrValue<BigNumberish> | null, destinationChainId?: PromiseOrValue<BigNumberish> | null, originToken?: PromiseOrValue<string> | null, depositsEnabled?: null): SetEnableDepositRouteEventFilter;
        'SetPoolRebalanceRoute(uint256,address,address)'(destinationChainId?: PromiseOrValue<BigNumberish> | null, l1Token?: PromiseOrValue<string> | null, destinationToken?: PromiseOrValue<string> | null): SetPoolRebalanceRouteEventFilter;
        SetPoolRebalanceRoute(destinationChainId?: PromiseOrValue<BigNumberish> | null, l1Token?: PromiseOrValue<string> | null, destinationToken?: PromiseOrValue<string> | null): SetPoolRebalanceRouteEventFilter;
        'SpokePoolAdminFunctionTriggered(uint256,bytes)'(chainId?: PromiseOrValue<BigNumberish> | null, message?: null): SpokePoolAdminFunctionTriggeredEventFilter;
        SpokePoolAdminFunctionTriggered(chainId?: PromiseOrValue<BigNumberish> | null, message?: null): SpokePoolAdminFunctionTriggeredEventFilter;
    };
    estimateGas: {
        addLiquidity(l1Token: PromiseOrValue<string>, l1TokenAmount: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        bondAmount(overrides?: CallOverrides): Promise<BigNumber>;
        bondToken(overrides?: CallOverrides): Promise<BigNumber>;
        claimProtocolFeesCaptured(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        crossChainContracts(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        disableL1TokenForLiquidityProvision(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        disputeRootBundle(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        emergencyDeleteProposal(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        enableL1TokenForLiquidityProvision(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        exchangeRateCurrent(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        executeRootBundle(chainId: PromiseOrValue<BigNumberish>, groupIndex: PromiseOrValue<BigNumberish>, bundleLpFees: PromiseOrValue<BigNumberish>[], netSendAmounts: PromiseOrValue<BigNumberish>[], runningBalances: PromiseOrValue<BigNumberish>[], leafId: PromiseOrValue<BigNumberish>, l1Tokens: PromiseOrValue<string>[], proof: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        finder(overrides?: CallOverrides): Promise<BigNumber>;
        getCurrentTime(overrides?: CallOverrides): Promise<BigNumber>;
        haircutReserves(l1Token: PromiseOrValue<string>, haircutAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        identifier(overrides?: CallOverrides): Promise<BigNumber>;
        liquidityUtilizationCurrent(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        liquidityUtilizationPostRelay(l1Token: PromiseOrValue<string>, relayedAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        liveness(overrides?: CallOverrides): Promise<BigNumber>;
        loadEthForL2Calls(overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        lpFeeRatePerSecond(overrides?: CallOverrides): Promise<BigNumber>;
        lpTokenFactory(overrides?: CallOverrides): Promise<BigNumber>;
        multicall(data: PromiseOrValue<BytesLike>[], overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        paused(overrides?: CallOverrides): Promise<BigNumber>;
        poolRebalanceRoute(destinationChainId: PromiseOrValue<BigNumberish>, l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        pooledTokens(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        proposeRootBundle(bundleEvaluationBlockNumbers: PromiseOrValue<BigNumberish>[], poolRebalanceLeafCount: PromiseOrValue<BigNumberish>, poolRebalanceRoot: PromiseOrValue<BytesLike>, relayerRefundRoot: PromiseOrValue<BytesLike>, slowRelayRoot: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        protocolFeeCaptureAddress(overrides?: CallOverrides): Promise<BigNumber>;
        protocolFeeCapturePct(overrides?: CallOverrides): Promise<BigNumber>;
        relaySpokePoolAdminFunction(chainId: PromiseOrValue<BigNumberish>, functionData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        removeLiquidity(l1Token: PromiseOrValue<string>, lpTokenAmount: PromiseOrValue<BigNumberish>, sendEth: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        rootBundleProposal(overrides?: CallOverrides): Promise<BigNumber>;
        setBond(newBondToken: PromiseOrValue<string>, newBondAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setCrossChainContracts(l2ChainId: PromiseOrValue<BigNumberish>, adapter: PromiseOrValue<string>, spokePool: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setCurrentTime(time: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setDepositRoute(originChainId: PromiseOrValue<BigNumberish>, destinationChainId: PromiseOrValue<BigNumberish>, originToken: PromiseOrValue<string>, depositsEnabled: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setIdentifier(newIdentifier: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setLiveness(newLiveness: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setPaused(pause: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setPoolRebalanceRoute(destinationChainId: PromiseOrValue<BigNumberish>, l1Token: PromiseOrValue<string>, destinationToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setProtocolFeeCapture(newProtocolFeeCaptureAddress: PromiseOrValue<string>, newProtocolFeeCapturePct: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        sync(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        timerAddress(overrides?: CallOverrides): Promise<BigNumber>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        unclaimedAccumulatedProtocolFees(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        weth(overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        addLiquidity(l1Token: PromiseOrValue<string>, l1TokenAmount: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        bondAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        bondToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        claimProtocolFeesCaptured(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        crossChainContracts(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        disableL1TokenForLiquidityProvision(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        disputeRootBundle(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        emergencyDeleteProposal(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        enableL1TokenForLiquidityProvision(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        exchangeRateCurrent(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        executeRootBundle(chainId: PromiseOrValue<BigNumberish>, groupIndex: PromiseOrValue<BigNumberish>, bundleLpFees: PromiseOrValue<BigNumberish>[], netSendAmounts: PromiseOrValue<BigNumberish>[], runningBalances: PromiseOrValue<BigNumberish>[], leafId: PromiseOrValue<BigNumberish>, l1Tokens: PromiseOrValue<string>[], proof: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        finder(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getCurrentTime(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        haircutReserves(l1Token: PromiseOrValue<string>, haircutAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        identifier(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        liquidityUtilizationCurrent(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        liquidityUtilizationPostRelay(l1Token: PromiseOrValue<string>, relayedAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        liveness(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        loadEthForL2Calls(overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        lpFeeRatePerSecond(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lpTokenFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        multicall(data: PromiseOrValue<BytesLike>[], overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        paused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        poolRebalanceRoute(destinationChainId: PromiseOrValue<BigNumberish>, l1Token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pooledTokens(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        proposeRootBundle(bundleEvaluationBlockNumbers: PromiseOrValue<BigNumberish>[], poolRebalanceLeafCount: PromiseOrValue<BigNumberish>, poolRebalanceRoot: PromiseOrValue<BytesLike>, relayerRefundRoot: PromiseOrValue<BytesLike>, slowRelayRoot: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        protocolFeeCaptureAddress(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolFeeCapturePct(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        relaySpokePoolAdminFunction(chainId: PromiseOrValue<BigNumberish>, functionData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        removeLiquidity(l1Token: PromiseOrValue<string>, lpTokenAmount: PromiseOrValue<BigNumberish>, sendEth: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        rootBundleProposal(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        setBond(newBondToken: PromiseOrValue<string>, newBondAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setCrossChainContracts(l2ChainId: PromiseOrValue<BigNumberish>, adapter: PromiseOrValue<string>, spokePool: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setCurrentTime(time: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setDepositRoute(originChainId: PromiseOrValue<BigNumberish>, destinationChainId: PromiseOrValue<BigNumberish>, originToken: PromiseOrValue<string>, depositsEnabled: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setIdentifier(newIdentifier: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setLiveness(newLiveness: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setPaused(pause: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setPoolRebalanceRoute(destinationChainId: PromiseOrValue<BigNumberish>, l1Token: PromiseOrValue<string>, destinationToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setProtocolFeeCapture(newProtocolFeeCaptureAddress: PromiseOrValue<string>, newProtocolFeeCapturePct: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        sync(l1Token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        timerAddress(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        unclaimedAccumulatedProtocolFees(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        weth(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}
