import { ZERO_ADDRESS_HEX_32 } from '@hyperlane-xyz/utils';
import { ISigner } from './altvm.js';
import { AnnotatedTx, TxReceipt } from './module.js';
export declare const ArtifactState: {
    readonly NEW: "new";
    readonly DEPLOYED: "deployed";
    readonly UNDERIVED: "underived";
};
export type ArtifactState = (typeof ArtifactState)[keyof typeof ArtifactState];
/**
 * Represents an artifact that has not yet been deployed.
 * Contains only the desired configuration.
 */
export type ArtifactNew<C> = {
    artifactState?: typeof ArtifactState.NEW;
    config: C;
};
/**
 * Represents an artifact that has been deployed on-chain.
 * Contains both the configuration and deployment-derived data (addresses, etc.).
 */
export type ArtifactDeployed<C, D> = {
    artifactState: typeof ArtifactState.DEPLOYED;
    config: C;
    deployed: D;
};
/**
 * Represents an artifact that has been deployed on chain
 * but is represented only by its address
 */
export type ArtifactUnderived<D> = {
    artifactState: typeof ArtifactState.UNDERIVED;
    deployed: D;
};
/**
 * Union type representing a deployed artifact. Can be either the full artifact config
 * or its address on chain.
 */
export type ArtifactOnChain<C, D> = ArtifactDeployed<C, D> | ArtifactUnderived<D>;
/**
 * Union type representing an artifact in any state.
 * Useful for APIs that can accept either new or deployed artifacts.
 */
export type Artifact<C, D = unknown> = ArtifactNew<C> | ArtifactDeployed<C, D> | ArtifactUnderived<D>;
/**
 * Type guard to check if an artifact is in the NEW state.
 * Returns true when artifactState is undefined (the default) or explicitly NEW.
 */
export declare function isArtifactNew<C, D>(artifact: Artifact<C, D>): artifact is ArtifactNew<C>;
/**
 * Type guard to check if an artifact is in the DEPLOYED state.
 */
export declare function isArtifactDeployed<C, D>(artifact: Artifact<C, D>): artifact is ArtifactDeployed<C, D>;
/**
 * Type guard to check if an artifact is in the UNDERIVED state.
 */
export declare function isArtifactUnderived<C, D>(artifact: Artifact<C, D>): artifact is ArtifactUnderived<D>;
/**
 * Interface for reading artifact state from the blockchain.
 */
export interface ArtifactReader<C, D> {
    /**
     * Read the current state of an artifact at the given address.
     * @param address The on-chain address of the artifact
     * @returns The artifact configuration and deployment data
     */
    read(address: string): Promise<ArtifactDeployed<C, D>>;
}
/**
 * Interface for creating and updating artifacts on the blockchain.
 */
export interface ArtifactWriter<C, D> extends ArtifactReader<C, D> {
    /**
     * Deploy a new artifact on-chain.
     * @param artifact The artifact configuration to deploy
     * @returns A tuple of [deployed artifact, transaction receipts]
     */
    create(artifact: ArtifactNew<C>): Promise<[ArtifactDeployed<C, D>, TxReceipt[]]>;
    /**
     * Update an existing artifact to match the desired configuration.
     * @param artifact The desired artifact state (must be deployed)
     * @returns Array of transactions needed to perform the update
     */
    update(artifact: ArtifactDeployed<C, D>): Promise<AnnotatedTx[]>;
}
/**
 * Utility type that converts Artifact<> references to ArtifactOnChain<> in a config type.
 * Used to create "raw" config types that protocol implementations work with.
 *
 * Transformations (non-recursive, single level only):
 * - Artifact<C, D> → ArtifactOnChain<C, D>
 * - Record<K, Artifact<C, D>> → Record<K, ArtifactOnChain<C, D>>
 * - Array<Artifact<C, D>> → Array<ArtifactOnChain<C, D>>
 * - Other properties remain unchanged
 *
 * This enables defining compound configs once and deriving raw configs automatically.
 *
 * Example:
 * ```typescript
 * interface RoutingIsmConfig {
 *   type: 'routing';
 *   owner: string;
 *   domains: Record<number, Artifact<IsmConfig, IsmDeployed>>;
 * }
 *
 * type RawRoutingIsmConfig = RawArtifact<RoutingIsmConfig, IsmDeployed>;
 * // Results in:
 * // {
 * //   type: 'routing';
 * //   owner: string;
 * //   domains: Record<number, ArtifactOnChain<IsmConfig, IsmDeployed>>;
 * // }
 * ```
 *
 * @deprecated FIXME: remove usage of this type in a follow up PR for the hook and ISM artifacts
 */
export type RawArtifact<C, D> = {
    [K in keyof C]: C[K] extends Artifact<infer CC> ? ArtifactOnChain<CC, D> : C[K] extends Artifact<infer CC>[] ? ArtifactOnChain<CC, D>[] : C[K] extends {
        [L: string]: Artifact<infer CC>;
    } ? {
        [L in keyof C[K]]: ArtifactOnChain<CC, D>;
    } : C[K];
};
/**
 * Helper type to transform nested objects containing Artifacts.
 * Handles objects where all properties are Artifacts (required or optional).
 */
type NestedOnChain<T> = T extends Record<string, unknown> ? {
    [L in keyof T]: T[L] extends Artifact<infer CC, infer DD> ? ArtifactOnChain<CC, DD> : T[L] extends Artifact<infer CC, infer DD> | undefined ? ArtifactOnChain<CC, DD> | undefined : T[L];
} : T;
/**
 * Utility type to convert a config type to its on-chain representation.
 * Replaces Artifact<> types one level deep with ArtifactOnChain<> types.
 * Unlike RawArtifact, preserves the nested deployment types.
 * Handles optional/undefined fields properly using conditional modifiers.
 */
export type ConfigOnChain<C> = {
    [K in keyof C]: C[K] extends Artifact<infer CC, infer DD> ? ArtifactOnChain<CC, DD> : C[K] extends Artifact<infer CC, infer DD> | undefined ? ArtifactOnChain<CC, DD> | undefined : C[K] extends Artifact<infer CC, infer DD>[] ? ArtifactOnChain<CC, DD>[] : NestedOnChain<C[K]>;
};
/**
 * Artifact Manager Interface
 *
 * Generic interface for managing artifact operations across different artifact types.
 * Can be specialized for ISMs, Hooks, Warp Routes, etc.
 *
 * Uses mapped types to enable proper type inference - when you call createReader(type),
 * TypeScript will infer the specific config type based on the type parameter.
 */
export interface IArtifactManager<TypeKey extends string, ConfigMap extends Record<TypeKey, unknown>, D> {
    createReader<T extends TypeKey>(type: T): ArtifactReader<ConfigMap[T], D>;
    createWriter<T extends TypeKey>(type: T, signer: ISigner<AnnotatedTx, TxReceipt>): ArtifactWriter<ConfigMap[T], D>;
}
export type UnsetArtifactAddress = typeof ZERO_ADDRESS_HEX_32;
/**
 * Returns the artifact if DEPLOYED, undefined if UNDERIVED with zero address.
 * Throws if UNDERIVED with non-zero address.
 */
export declare function toDeployedOrUndefined<C, D extends {
    address: string;
}>(artifact: ArtifactOnChain<C, D>, name: string): ArtifactDeployed<C, D> | undefined;
export declare function addressToUnderivedArtifact(address: string | undefined, formatter?: (value: string) => string): ArtifactUnderived<{
    address: string;
}> | undefined;
export declare function artifactOnChainToAddress<C>(artifact: ArtifactOnChain<C, {
    address: string;
}> | undefined, formatter?: (value: string) => string): string | undefined;
export {};
//# sourceMappingURL=artifact.d.ts.map