import { type FederationInfo } from '@softarc/native-federation/domain';
import { type InitFederationOptions, type ProcessRemoteInfoOptions } from './model/federation-info.js';
import { type ImportMap } from './model/import-map.js';
/**
 * Initializes the Native Federation runtime for the host application.
 *
 * This is the main entry point for setting up federation. It performs the following:
 * 1. Loads the host's remoteEntry.json to discover shared dependencies
 * 2. Loads each remote's remoteEntry.json to discover exposed modules
 * 3. Creates an ES Module import map with proper scoping
 * 4. Injects the import map into the DOM as a <script type="importmap-shim">
 *
 * The import map allows dynamic imports to resolve correctly:
 * - Host shared deps go in root imports (e.g., "angular": "./angular.js")
 * - Remote exposed modules go in root imports (e.g., "mfe1/Component": "http://...")
 * - Remote shared deps go in scoped imports for proper resolution
 *
 * @param remotesOrManifestUrl - Either:
 *   - A record of remote names to their remoteEntry.json URLs
 *     Example: { mfe1: 'http://localhost:3000/remoteEntry.json' }
 *   - A URL to a manifest.json that contains the remotes record
 *     Example: 'http://localhost:3000/federation-manifest.json'
 *
 * @param options - Configuration options:
 *   - cacheTag: A version string to append as query param for cache busting
 *     Example: { cacheTag: 'v1.0.0' } results in '?t=v1.0.0' on all requests
 *
 * @returns The final merged ImportMap that was injected into the DOM
 *
 * @deprecated This package has reached end-of-life and is no longer maintained.
 *   Please switch over to the @softarc/native-federation-orchestrator library.
 */
export declare function initFederation(remotesOrManifestUrl?: Record<string, string> | string, options?: InitFederationOptions): Promise<ImportMap>;
/**
 * Fetches and registers multiple remote applications in parallel and merges their import maps.
 *
 * This function is the orchestrator for loading all remotes. It:
 * 1. Creates a promise for each remote to load its remoteEntry.json
 * 2. Applies cache busting to each remote URL
 * 3. Handles errors gracefully (logs or throws based on options)
 * 4. Merges all successful remote import maps into one
 *
 * Each remote contributes:
 * - Its exposed modules to the root imports
 * - Its shared dependencies to scoped imports
 *
 * @param remotes - Record of remote names to their remoteEntry.json URLs
 * @param options - Processing options including:
 *   - throwIfRemoteNotFound: Whether to throw or log on remote load failure
 *   - cacheTag: Cache busting tag to append to URLs
 *
 * @returns Merged import map containing all remotes' contributions
 *
 * @deprecated This package has reached end-of-life and is no longer maintained.
 *   Please switch over to the @softarc/native-federation-orchestrator library.
 */
export declare function fetchAndRegisterRemotes(remotes: Record<string, string>, options?: ProcessRemoteInfoOptions): Promise<ImportMap>;
/**
 * @deprecated This package has reached end-of-life and is no longer maintained.
 *   Please switch over to the @softarc/native-federation-orchestrator library.
 *   (Previously: use `fetchAndRegisterRemotes` instead.)
 * @param remotes
 * @param options
 * @returns
 */
export declare function processRemoteInfos(remotes: Record<string, string>, options?: ProcessRemoteInfoOptions): Promise<ImportMap>;
/**
 * Fetches a single remote application's remoteEntry.json file and registers it in the system (global registry).
 *
 * This function handles everything needed to integrate one remote:
 * 1. Fetches the remote's remoteEntry.json file
 * 2. Extracts the base URL from the remoteEntry path
 * 3. Creates import map entries for exposed modules and shared deps
 * 4. Registers the remote in the global remotes registry
 * 5. Sets up hot reload watching if configured (development mode)
 *
 * @param federationInfoUrl - Full URL to the remote's remoteEntry.json
 * @param remoteName - Name to use for this remote (optional, uses info.name if not provided)
 *
 * @returns Import map containing this remote's exposed modules and shared dependencies
 *
 * @example
 * ```typescript
 * const importMap = await fetchAndRegisterRemote(
 *   'http://localhost:3000/mfe1/remoteEntry.json',
 *   'mfe1'
 * );
 * // Result: {
 * //   imports: { 'mfe1/Component': 'http://localhost:3000/mfe1/Component.js' },
 * //   scopes: { 'http://localhost:3000/mfe1/': { 'lodash': '...' } }
 * // }
 * ```
 *
 * @deprecated This package has reached end-of-life and is no longer maintained.
 *   Please switch over to the @softarc/native-federation-orchestrator library.
 */
export declare function fetchAndRegisterRemote(federationInfoUrl: string, remoteName?: string): Promise<ImportMap>;
/**
 * Processes the host application's federation info into an import map.
 *
 * The host app typically doesn't expose modules (it's the consumer),
 * but it does share dependencies that should be available to remotes.
 *
 * Host shared dependencies go in root-level imports (not scoped) because:
 * 1. The host loads first and establishes the base environment
 * 2. Remotes should prefer host versions to avoid duplication
 *
 * @param hostInfo - Federation info from the host's remoteEntry.json
 * @param relBundlesPath - Relative path to the host's bundle directory (default: './')
 *
 * @returns Import map with host's shared dependencies in root imports
 *
 * @deprecated This package has reached end-of-life and is no longer maintained.
 *   Please switch over to the @softarc/native-federation-orchestrator library.
 */
export declare function processHostInfo(hostInfo: FederationInfo, relBundlesPath?: string): Promise<ImportMap>;