import { Logger } from 'pino';
import { Address, Domain, EvmChainId, ProtocolType } from '@hyperlane-xyz/utils';
import { CCIPContractCache } from '../ccip/utils.js';
import { HyperlaneAddresses } from '../contracts/types.js';
import { HyperlaneModule, HyperlaneModuleParams } from '../core/AbstractHyperlaneModule.js';
import { ProxyFactoryFactories } from '../deploy/contracts.js';
import { ContractVerifier } from '../deploy/verify/ContractVerifier.js';
import { MultiProvider } from '../providers/MultiProvider.js';
import { AnnotatedEV5Transaction } from '../providers/ProviderType.js';
import { ChainName, ChainNameOrId } from '../types.js';
import { EvmIsmReader } from './EvmIsmReader.js';
import { HyperlaneIsmFactory } from './HyperlaneIsmFactory.js';
import { BlacklistIsmConfig, DelayedFlowRouterHookIsmConfig, DeployedIsm, DomainRoutingIsmConfig, IsmConfig, NetFlowRateLimitedHookIsmConfig, OffchainLookupIsmConfig, PausableIsmConfig, RateLimitedIsmConfig } from './types.js';
type IsmModuleAddresses = {
    deployedIsm: Address;
    mailbox: Address;
};
export declare class EvmIsmModule extends HyperlaneModule<ProtocolType.Ethereum, IsmConfig, HyperlaneAddresses<ProxyFactoryFactories> & IsmModuleAddresses> {
    protected readonly multiProvider: MultiProvider;
    protected readonly ccipContractCache?: CCIPContractCache | undefined;
    protected readonly contractVerifier?: ContractVerifier | undefined;
    static protocols: ProtocolType[];
    protected readonly logger: import("pino").pino.Logger<never>;
    protected readonly reader: EvmIsmReader;
    protected readonly ismFactory: HyperlaneIsmFactory;
    protected readonly mailbox: Address;
    readonly chain: ChainName;
    readonly chainId: EvmChainId;
    readonly domainId: Domain;
    constructor(multiProvider: MultiProvider, params: HyperlaneModuleParams<IsmConfig, HyperlaneAddresses<ProxyFactoryFactories> & IsmModuleAddresses>, ccipContractCache?: CCIPContractCache | undefined, contractVerifier?: ContractVerifier | undefined);
    read(): Promise<IsmConfig>;
    update(targetConfig: IsmConfig, opaqueHybridAddresses?: Address[]): Promise<AnnotatedEV5Transaction[]>;
    /**
     * Reconciles a single already-deployed ISM instance, skipping the
     * route-level composition rules that `update()` enforces.
     *
     * Composition (e.g. "a hybrid hook/ISM must sit in a mandatory aggregation
     * beside an authenticating ISM") is a property of the tree installed on a
     * router, and is validated where that tree is expressed — the warp/core
     * config schemas and the deploy-time guards. This entry point does not
     * install anything on a router; it emits transactions against an instance
     * that already passed those checks (cross-chain enrollment of a
     * DelayedFlowRouterHookIsm being the motivating case), so applying the
     * composition rules to the bare node here would reject a legitimate
     * operation.
     *
     * Restricted to a single leaf node so the escape hatch cannot express a
     * composed tree at all: anything that aggregates or routes must go through
     * `update()`, where the composition rules run.
     */
    updateDeployedInstance(targetConfig: IsmConfig): Promise<AnnotatedEV5Transaction[]>;
    private updateInternal;
    protected updateMutableIsm({ current, target, }: {
        current: Exclude<IsmConfig, string>;
        target: Exclude<IsmConfig, string>;
    }): Promise<AnnotatedEV5Transaction[]>;
    static create({ chain, config, proxyFactoryFactories, mailbox, multiProvider, ccipContractCache, contractVerifier, }: {
        chain: ChainNameOrId;
        config: IsmConfig;
        proxyFactoryFactories: HyperlaneAddresses<ProxyFactoryFactories>;
        mailbox: Address;
        multiProvider: MultiProvider;
        ccipContractCache?: CCIPContractCache;
        contractVerifier?: ContractVerifier;
    }): Promise<EvmIsmModule>;
    protected updateRoutingIsm({ current, target, logger, }: {
        current: DomainRoutingIsmConfig;
        target: DomainRoutingIsmConfig;
        logger: Logger;
    }): Promise<AnnotatedEV5Transaction[]>;
    protected updatePausableIsm({ current, target, }: {
        current: PausableIsmConfig;
        target: PausableIsmConfig;
    }): Promise<AnnotatedEV5Transaction[]>;
    protected updateOffchainLookupIsm({ current, target, }: {
        current: OffchainLookupIsmConfig;
        target: OffchainLookupIsmConfig;
    }): AnnotatedEV5Transaction[];
    protected updateRateLimitedIsm({ current, target, }: {
        current: RateLimitedIsmConfig;
        target: RateLimitedIsmConfig;
    }): AnnotatedEV5Transaction[];
    private isEnumerableBlacklistIsm;
    private blacklistCanBeUpdatedInPlace;
    protected updateBlacklistIsm({ current, target, }: {
        current: BlacklistIsmConfig;
        target: BlacklistIsmConfig;
    }): AnnotatedEV5Transaction[];
    protected updateNetFlowRateLimitedIsm({ current, target, }: {
        current: NetFlowRateLimitedHookIsmConfig;
        target: NetFlowRateLimitedHookIsmConfig;
    }): AnnotatedEV5Transaction[];
    protected updateDelayedFlowRouterIsm({ target, }: {
        target: DelayedFlowRouterHookIsmConfig;
    }): Promise<AnnotatedEV5Transaction[]>;
    protected deploy({ config, }: {
        config: IsmConfig;
    }): Promise<DeployedIsm>;
    private tryUpdateContainerIsm;
    private containerSubModules;
    private canUpdateSubModuleInPlace;
    private ismConfigSortKey;
    private hasDuplicateSortKeys;
}
export {};
//# sourceMappingURL=EvmIsmModule.d.ts.map