import { Logger } from 'pino';
import { ArbL2ToL1Ism__factory, BlacklistIsm__factory, CCIPIsm, CCIPIsm__factory, DefaultFallbackRoutingIsm, DefaultIsm__factory, DelayedFlowRouterHookIsm__factory, DomainRoutingIsm, IAggregationIsm, IMultisigIsm, IncrementalDomainRoutingIsm, IRoutingIsm, IStaticWeightedMultisigIsm, NetFlowRateLimitedHookIsm__factory, OPStackIsm__factory, PausableIsm__factory, RateLimitedIsm__factory, StaticAddressSetFactory, StaticThresholdAddressSetFactory, StaticWeightedValidatorSetFactory, TestIsm__factory, TrustedRelayerIsm__factory } from '@hyperlane-xyz/core';
import { Address } from '@hyperlane-xyz/utils';
import { HyperlaneApp } from '../app/HyperlaneApp.js';
import { CCIPContractCache } from '../ccip/utils.js';
import { HyperlaneAddressesMap, HyperlaneContractsMap } from '../contracts/types.js';
import { HyperlaneDeployer } from '../deploy/HyperlaneDeployer.js';
import { ProxyFactoryFactories } from '../deploy/contracts.js';
import { ContractVerifier } from '../deploy/verify/ContractVerifier.js';
import { MultiProvider } from '../providers/MultiProvider.js';
import { ChainMap, ChainName } from '../types.js';
import { AggregationIsmConfig, BlacklistIsmConfig, CCIPIsmConfig, CompositeIsmConfig, DeployedIsm, DeployedIsmType, IsmConfig, IsmType, MultisigIsmConfig, PausableIsmConfig, RoutingIsmConfig, RoutingMessageIdMultisigIsmConfig, WeightedMultisigIsmConfig } from './types.js';
declare const ismFactories: {
    pausableIsm: PausableIsm__factory;
    trustedRelayerIsm: TrustedRelayerIsm__factory;
    testIsm: TestIsm__factory;
    opStackIsm: OPStackIsm__factory;
    arbL2ToL1Ism: ArbL2ToL1Ism__factory;
    ccipIsm: CCIPIsm__factory;
    rateLimitedIsm: RateLimitedIsm__factory;
    blacklistIsm: BlacklistIsm__factory;
    defaultIsm: DefaultIsm__factory;
    netFlowRateLimitedHookIsm: NetFlowRateLimitedHookIsm__factory;
    delayedFlowRouterHookIsm: DelayedFlowRouterHookIsm__factory;
};
/**
 * Recursively rejects Sealevel-only ISMs (Composite, RoutingMessageIdMultisig)
 * anywhere in an EVM ISM config tree, including nested under
 * AGGREGATION/ROUTING/AMOUNT_ROUTING — called once up front so an invalid
 * nested config is caught before any sibling module in the tree is deployed
 * on-chain.
 */
export declare function assertNoSealevelOnlyIsm(config: IsmConfig): asserts config is Exclude<IsmConfig, CompositeIsmConfig | RoutingMessageIdMultisigIsmConfig>;
/**
 * Asserts that every domain -> submodule mapping already configured on a
 * routing ISM found already-initialized matches what this deploy expected to
 * configure. Owner matching alone isn't sufficient: a resumed deploy whose
 * nested submodules landed on different addresses than this attempt (e.g. a
 * raw-CREATE nested routing ISM re-deployed with a new nonce-based address),
 * or someone else's initialize() call, can leave a routing ISM correctly
 * owned but wired to the wrong submodules.
 */
export declare function assertSubmodulesMatchExpected(routingIsm: DomainRoutingIsm | IncrementalDomainRoutingIsm | DefaultFallbackRoutingIsm, expectedDomains: number[], expectedModules: Address[], destination: ChainName): Promise<void>;
declare class IsmDeployer extends HyperlaneDeployer<{}, typeof ismFactories> {
    protected readonly cachingEnabled = false;
    deployContracts(_chain: ChainName, _config: any): Promise<any>;
}
export declare class HyperlaneIsmFactory extends HyperlaneApp<ProxyFactoryFactories> {
    readonly multiProvider: MultiProvider;
    readonly ccipContractCache: CCIPContractCache;
    deployedIsms: ChainMap<any>;
    protected readonly deployer: IsmDeployer;
    private supportsBatchCache;
    constructor(contractsMap: HyperlaneContractsMap<ProxyFactoryFactories>, multiProvider: MultiProvider, ccipContractCache?: CCIPContractCache, contractVerifier?: ContractVerifier);
    static fromAddressesMap(addressesMap: HyperlaneAddressesMap<any>, multiProvider: MultiProvider, ccipContractCache?: CCIPContractCache, contractVerifier?: ContractVerifier): HyperlaneIsmFactory;
    deploy<C extends IsmConfig>(params: {
        destination: ChainName;
        config: C;
        origin?: ChainName;
        mailbox?: Address;
        existingIsmAddress?: Address;
    }): Promise<DeployedIsm>;
    /**
     * @internal Structural deploy primitive for recursion and pre-validated
     * callers. Assumes the composition rules of the whole ISM tree have already
     * been validated via IsmConfigSchema (e.g. by the public deploy() or
     * EvmIsmModule.create/update). Do not call directly from application code.
     *
     * It cannot be `protected` — EvmIsmModule deploys sub-trees through it, and
     * those are exactly the nodes IsmConfigSchema rejects on their own (a hybrid
     * hook/ISM outside its mandatory aggregation, say) — so the shape of every
     * node it is handed is re-validated here instead. Only the composition rules
     * are taken on trust; a caller reaching this directly still cannot deploy a
     * malformed config.
     */
    deployInternal<C extends IsmConfig>(params: {
        destination: ChainName;
        config: C;
        origin?: ChainName;
        mailbox?: Address;
        existingIsmAddress?: Address;
    }): Promise<DeployedIsm>;
    private reconcileRecoveredPausableIsm;
    protected deployCCIPIsm(destination: ChainName, config: CCIPIsmConfig): Promise<CCIPIsm>;
    protected deployBlacklistIsm(destination: ChainName, config: BlacklistIsmConfig): Promise<DeployedIsmType[typeof IsmType.BLACKLIST]>;
    protected deployPausableIsm(destination: ChainName, config: PausableIsmConfig): Promise<DeployedIsmType[typeof IsmType.PAUSABLE]>;
    protected deployMultisigIsm(destination: ChainName, config: MultisigIsmConfig, logger: Logger): Promise<IMultisigIsm>;
    protected deployWeightedMultisigIsm(destination: ChainName, config: WeightedMultisigIsmConfig, logger: Logger): Promise<IMultisigIsm>;
    protected deployRoutingIsm(params: {
        destination: ChainName;
        config: RoutingIsmConfig;
        origin?: ChainName;
        mailbox?: Address;
        existingIsmAddress?: Address;
        logger: Logger;
    }): Promise<IRoutingIsm>;
    private deployAmountRoutingIsm;
    private deployOwnableRoutingIsm;
    /**
     * Resolves whether a routing ISM's deployed bytecode has the
     * `setIsms`/`removeIsms` ops (introduced in `@hyperlane-xyz/core`
     * 12.0.0). Memoized per chain+address.
     */
    private routingIsmSupportsBatch;
    /**
     * Enroll a set of (domain, ISM address) pairs on a routing ISM. Uses
     * `setIsms` chunked by `batchSize` when the deployed ISM supports it;
     * otherwise falls back to a per-domain `set` loop.
     */
    private enrollDomains;
    /**
     * Unenroll a set of domains from a routing ISM. Uses `removeIsms`
     * chunked by `batchSize` when supported; otherwise falls back to a
     * per-domain `remove` loop.
     */
    private unenrollDomains;
    protected deployAggregationIsm(params: {
        destination: ChainName;
        config: AggregationIsmConfig;
        origin?: ChainName;
        mailbox?: Address;
        logger: Logger;
    }): Promise<IAggregationIsm>;
    deployStaticAddressSet(chain: ChainName, factory: StaticThresholdAddressSetFactory | StaticAddressSetFactory, values: Address[], logger: Logger, threshold?: number): Promise<Address>;
    deployStaticWeightedValidatorSet(chain: ChainName, factory: StaticWeightedValidatorSetFactory, values: IStaticWeightedMultisigIsm.ValidatorInfoStruct[], thresholdWeight: number | undefined, logger: Logger): Promise<Address>;
    private previewFactoryDeployAddress;
}
export {};
//# sourceMappingURL=HyperlaneIsmFactory.d.ts.map