import { CreateScriptHookReturn, GlobalModuleInfo, Manifest, Module, ModuleInfo, RemoteEntryType, RemoteWithEntry, RemoteWithVersion, TreeShakingStatus } from "@module-federation/sdk";

//#region ../runtime-core/dist/utils/hooks/syncHook.d.ts
//#region src/utils/hooks/syncHook.d.ts
type Callback<T, K> = (...args: ArgsType<T>) => K;
type ArgsType<T> = T extends Array<any> ? T : Array<any>;
declare class SyncHook<T, K> {
  type: string;
  listeners: Set<Callback<T, K>>;
  constructor(type?: string);
  on(fn: Callback<T, K>): void;
  once(fn: Callback<T, K>): void;
  emit(...data: ArgsType<T>): void | K | Promise<any>;
  remove(fn: Callback<T, K>): void;
  removeAll(): void;
} //#endregion
//#endregion
//#region ../runtime-core/dist/utils/hooks/asyncHook.d.ts
//#region src/utils/hooks/asyncHook.d.ts
type CallbackReturnType$1 = void | false | Promise<void | false>;
declare class AsyncHook<T, ExternalEmitReturnType = CallbackReturnType$1> extends SyncHook<T, ExternalEmitReturnType> {
  emit(...data: ArgsType<T>): Promise<void | false | ExternalEmitReturnType>;
} //#endregion
//#endregion
//#region ../runtime-core/dist/utils/hooks/syncWaterfallHook.d.ts
//#region src/utils/hooks/syncWaterfallHook.d.ts
declare class SyncWaterfallHook<T extends Record<string, any>> extends SyncHook<[T], T> {
  onerror: (errMsg: string | Error | unknown) => void;
  constructor(type: string);
  emit(data: T): T;
} //#endregion
//#endregion
//#region ../runtime-core/dist/utils/hooks/asyncWaterfallHooks.d.ts
//#region src/utils/hooks/asyncWaterfallHooks.d.ts
type CallbackReturnType<T> = T | Promise<T>;
declare class AsyncWaterfallHook<T extends Record<string, any>> extends SyncHook<[T], CallbackReturnType<T>> {
  onerror: (errMsg: string | Error | unknown) => void;
  constructor(type: string);
  emit(data: T): Promise<T>;
} //#endregion
//#endregion
//#region ../runtime-core/dist/utils/hooks/pluginSystem.d.ts
//#region src/utils/hooks/pluginSystem.d.ts
type Plugin<T extends Record<string, any>> = { [k in keyof T]?: Parameters<T[k]['on']>[0] } & {
  name: string;
  version?: string;
  apply?: (instance: ModuleFederation) => void;
};
declare class PluginSystem<T extends Record<string, any>> {
  lifecycle: T;
  lifecycleKeys: Array<keyof T>;
  registerPlugins: Record<string, Plugin<T>>;
  constructor(lifecycle: T);
  applyPlugin(plugin: Plugin<T>, instance: ModuleFederation): void;
  removePlugin(pluginName: string): void;
} //#endregion
//#endregion
//#region ../runtime-core/dist/type/config.d.ts
//#region src/type/config.d.ts
type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
interface RemoteInfoCommon {
  alias?: string;
  shareScope?: string | string[];
  type?: RemoteEntryType;
  entryGlobalName?: string;
}
type Remote = (RemoteWithEntry | RemoteWithVersion) & RemoteInfoCommon;
interface RemoteInfo {
  alias?: string;
  name: string;
  version?: string;
  buildVersion?: string;
  entry: string;
  type: RemoteEntryType;
  entryGlobalName: string;
  shareScope: string | string[];
}
interface SharedConfig {
  singleton?: boolean;
  requiredVersion: false | string;
  eager?: boolean;
  strictVersion?: boolean;
  layer?: string | null;
}
type TreeShakingArgs = {
  usedExports?: string[];
  get?: SharedGetter;
  lib?: () => Module;
  status?: TreeShakingStatus;
  mode?: 'server-calc' | 'runtime-infer';
  loading?: null | Promise<any>;
  loaded?: boolean;
  useIn?: Array<string>;
};
type SharedBaseArgs = {
  version?: string;
  shareConfig?: SharedConfig;
  scope?: string | Array<string>;
  deps?: Array<string>;
  strategy?: 'version-first' | 'loaded-first';
  loaded?: boolean;
  treeShaking?: TreeShakingArgs;
};
type SharedGetter = (() => () => Module) | (() => Promise<() => Module>);
type ShareArgs = (SharedBaseArgs & {
  get: SharedGetter;
}) | (SharedBaseArgs & {
  lib: () => Module;
}) | SharedBaseArgs;
type ShareStrategy = 'version-first' | 'loaded-first';
type Shared = {
  version: string;
  get: SharedGetter;
  shareConfig: SharedConfig;
  scope: Array<string>;
  useIn: Array<string>;
  from: string;
  deps: Array<string>;
  lib?: () => Module;
  loaded?: boolean;
  loading?: null | Promise<any>;
  eager?: boolean;
  /**
   * @deprecated set in initOptions.shareStrategy instead
   */
  strategy: ShareStrategy;
  treeShaking?: TreeShakingArgs;
};
type ShareScopeMap = {
  [scope: string]: {
    [pkgName: string]: {
      [sharedVersion: string]: Shared;
    };
  };
};
type GlobalShareScopeMap = {
  [instanceName: string]: ShareScopeMap;
};
type ShareInfos = {
  [pkgName: string]: Shared[];
};
interface Options {
  id?: string;
  name: string;
  version?: string;
  remotes: Array<Remote>;
  shared: ShareInfos;
  plugins: Array<ModuleFederationRuntimePlugin>;
  inBrowser: boolean;
  shareStrategy?: ShareStrategy;
}
type UserOptions = Omit<Optional<Options, 'plugins'>, 'shared' | 'inBrowser'> & {
  shared?: {
    [pkgName: string]: ShareArgs | ShareArgs[];
  };
};
type RemoteEntryInitOptions = {
  version: string;
  shareScopeMap?: ShareScopeMap;
  shareScopeKeys: string | string[];
};
type InitTokens = Record<string, Record<string, any>>;
type InitScope = InitTokens[];
type CallFrom = 'build' | 'runtime';
type RemoteEntryExports = {
  get: (id: string) => () => Promise<Module>;
  init: (shareScope: ShareScopeMap[string], initScope?: InitScope, remoteEntryInitOPtions?: RemoteEntryInitOptions) => void | Promise<void>;
}; //#endregion
//#endregion
//#region ../runtime-core/dist/type/preload.d.ts
//#region src/type/preload.d.ts
type depsPreloadArg = Omit<PreloadRemoteArgs, 'depsRemote'>;
interface PreloadRemoteArgs {
  nameOrAlias: string;
  exposes?: Array<string>;
  resourceCategory?: 'all' | 'sync';
  share?: boolean;
  depsRemote?: boolean | Array<depsPreloadArg>;
  filter?: (assetUrl: string) => boolean;
  prefetchInterface?: boolean;
}
type PreloadConfig = PreloadRemoteArgs;
type PreloadOptions = Array<{
  remote: Remote;
  preloadConfig: PreloadConfig;
}>;
type EntryAssets = {
  name: string;
  url: string;
  moduleInfo: RemoteInfo;
};
interface PreloadAssets {
  cssAssets: Array<string>;
  jsAssetsWithoutEntry: Array<string>;
  entryAssets: Array<EntryAssets>;
} //#endregion
//#endregion
//#region ../runtime-core/dist/remote/index.d.ts
//#region src/remote/index.d.ts
interface LoadRemoteMatch {
  id: string;
  pkgNameOrAlias: string;
  expose: string;
  remote: Remote;
  options: Options;
  origin: ModuleFederation;
  remoteInfo: RemoteInfo;
  remoteSnapshot?: ModuleInfo;
}
declare class RemoteHandler {
  host: ModuleFederation;
  idToRemoteMap: Record<string, {
    name: string;
    expose: string;
  }>;
  hooks: PluginSystem<{
    beforeRegisterRemote: SyncWaterfallHook<{
      remote: Remote;
      origin: ModuleFederation;
    }>;
    registerRemote: SyncWaterfallHook<{
      remote: Remote;
      origin: ModuleFederation;
    }>;
    beforeRequest: AsyncWaterfallHook<{
      id: string;
      options: Options;
      origin: ModuleFederation;
    }>;
    onLoad: AsyncHook<[{
      id: string;
      expose: string;
      pkgNameOrAlias: string;
      remote: Remote;
      options: ModuleOptions;
      origin: ModuleFederation;
      exposeModule: any;
      exposeModuleFactory: any;
      moduleInstance: Module$1;
    }], void>;
    handlePreloadModule: SyncHook<[{
      id: string;
      name: string;
      remote: Remote;
      remoteSnapshot: ModuleInfo;
      preloadConfig: PreloadRemoteArgs;
      origin: ModuleFederation;
    }], void>;
    errorLoadRemote: AsyncHook<[{
      id: string;
      error: unknown;
      options?: any;
      from: CallFrom;
      lifecycle: "beforeRequest" | "beforeLoadShare" | "afterResolve" | "onLoad";
      origin: ModuleFederation;
    }], unknown>;
    beforePreloadRemote: AsyncHook<[{
      preloadOps: Array<PreloadRemoteArgs>;
      options: Options;
      origin: ModuleFederation;
    }], false | void | Promise<false | void>>;
    generatePreloadAssets: AsyncHook<[{
      origin: ModuleFederation;
      preloadOptions: PreloadOptions[number];
      remote: Remote;
      remoteInfo: RemoteInfo;
      remoteSnapshot: ModuleInfo;
      globalSnapshot: GlobalModuleInfo;
    }], Promise<PreloadAssets>>;
    afterPreloadRemote: AsyncHook<{
      preloadOps: Array<PreloadRemoteArgs>;
      options: Options;
      origin: ModuleFederation;
    }, false | void | Promise<false | void>>;
    loadEntry: AsyncHook<[{
      loaderHook: ModuleFederation["loaderHook"];
      remoteInfo: RemoteInfo;
      remoteEntryExports?: RemoteEntryExports;
    }], Promise<RemoteEntryExports>>;
  }>;
  constructor(host: ModuleFederation);
  formatAndRegisterRemote(globalOptions: Options, userOptions: UserOptions): Remote[];
  setIdToRemoteMap(id: string, remoteMatchInfo: LoadRemoteMatch): void;
  loadRemote<T>(id: string, options?: {
    loadFactory?: boolean;
    from: CallFrom;
  }): Promise<T | null>;
  preloadRemote(preloadOptions: Array<PreloadRemoteArgs>): Promise<void>;
  registerRemotes(remotes: Remote[], options?: {
    force?: boolean;
  }): void;
  getRemoteModuleAndOptions(options: {
    id: string;
  }): Promise<{
    module: Module$1;
    moduleOptions: ModuleOptions;
    remoteMatchInfo: LoadRemoteMatch;
  }>;
  registerRemote(remote: Remote, targetRemotes: Remote[], options?: {
    force?: boolean;
  }): void;
  private removeRemote;
} //#endregion
//#endregion
//#region ../runtime-core/dist/shared/index.d.ts
//#region src/shared/index.d.ts
declare class SharedHandler {
  host: ModuleFederation;
  shareScopeMap: ShareScopeMap;
  hooks: PluginSystem<{
    beforeRegisterShare: SyncWaterfallHook<{
      pkgName: string;
      shared: Shared;
      origin: ModuleFederation;
    }>;
    afterResolve: AsyncWaterfallHook<LoadRemoteMatch>;
    beforeLoadShare: AsyncWaterfallHook<{
      pkgName: string;
      shareInfo?: Shared;
      shared: Options["shared"];
      origin: ModuleFederation;
    }>;
    loadShare: AsyncHook<[ModuleFederation, string, ShareInfos], false | void | Promise<false | void>>;
    resolveShare: SyncWaterfallHook<{
      shareScopeMap: ShareScopeMap;
      scope: string;
      pkgName: string;
      version: string;
      shareInfo: Shared;
      GlobalFederation: Federation;
      resolver: () => {
        shared: Shared;
        useTreesShaking: boolean;
      } | undefined;
    }>;
    initContainerShareScopeMap: SyncWaterfallHook<{
      shareScope: ShareScopeMap[string];
      options: Options;
      origin: ModuleFederation;
      scopeName: string;
      hostShareScopeMap?: ShareScopeMap;
    }>;
  }>;
  initTokens: InitTokens;
  constructor(host: ModuleFederation);
  registerShared(globalOptions: Options, userOptions: UserOptions): {
    newShareInfos: ShareInfos;
    allShareInfos: {
      [pkgName: string]: Shared[];
    };
  };
  loadShare<T>(pkgName: string, extraOptions?: {
    customShareInfo?: Partial<Shared>;
    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
  }): Promise<false | (() => T | undefined)>;
  /**
   * This function initializes the sharing sequence (executed only once per share scope).
   * It accepts one argument, the name of the share scope.
   * If the share scope does not exist, it creates one.
   */
  initializeSharing(shareScopeName?: string, extraOptions?: {
    initScope?: InitScope;
    from?: CallFrom;
    strategy?: ShareStrategy;
  }): Array<Promise<void>>;
  loadShareSync<T>(pkgName: string, extraOptions?: {
    from?: 'build' | 'runtime';
    customShareInfo?: Partial<Shared>;
    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
  }): () => T | never;
  initShareScopeMap(scopeName: string, shareScope: ShareScopeMap[string], extraOptions?: {
    hostShareScopeMap?: ShareScopeMap;
  }): void;
  private setShared;
  private _setGlobalShareScopeMap;
} //#endregion
//#endregion
//#region ../runtime-core/dist/type/plugin.d.ts
//#region src/type/plugin.d.ts
type CoreLifeCycle = ModuleFederation['hooks']['lifecycle'];
type CoreLifeCyclePartial = Partial<{ [k in keyof CoreLifeCycle]: Parameters<CoreLifeCycle[k]['on']>[0] }>;
type SnapshotLifeCycle = SnapshotHandler['hooks']['lifecycle'];
type SnapshotLifeCycleCyclePartial = Partial<{ [k in keyof SnapshotLifeCycle]: Parameters<SnapshotLifeCycle[k]['on']>[0] }>;
type ModuleLifeCycle = Module$1['host']['loaderHook']['lifecycle'];
type ModuleLifeCycleCyclePartial = Partial<{ [k in keyof ModuleLifeCycle]: Parameters<ModuleLifeCycle[k]['on']>[0] }>;
type ModuleBridgeLifeCycle = Module$1['host']['bridgeHook']['lifecycle'];
type ModuleBridgeLifeCycleCyclePartial = Partial<{ [k in keyof ModuleBridgeLifeCycle]: Parameters<ModuleBridgeLifeCycle[k]['on']>[0] }>;
type SharedLifeCycle = SharedHandler['hooks']['lifecycle'];
type SharedLifeCycleCyclePartial = Partial<{ [k in keyof SharedLifeCycle]: Parameters<SharedLifeCycle[k]['on']>[0] }>;
type RemoteLifeCycle = RemoteHandler['hooks']['lifecycle'];
type RemoteLifeCycleCyclePartial = Partial<{ [k in keyof RemoteLifeCycle]: Parameters<RemoteLifeCycle[k]['on']>[0] }>;
type ModuleFederationRuntimePlugin = CoreLifeCyclePartial & SnapshotLifeCycleCyclePartial & SharedLifeCycleCyclePartial & RemoteLifeCycleCyclePartial & ModuleLifeCycleCyclePartial & ModuleBridgeLifeCycleCyclePartial & {
  name: string;
  version?: string;
  apply?: (instance: ModuleFederation) => void;
}; //#endregion
//#endregion
//#region ../runtime-core/dist/global.d.ts
//#region src/global.d.ts
interface Federation {
  __GLOBAL_PLUGIN__: Array<ModuleFederationRuntimePlugin>;
  __DEBUG_CONSTRUCTOR_VERSION__?: string;
  moduleInfo: GlobalModuleInfo;
  __DEBUG_CONSTRUCTOR__?: typeof ModuleFederation;
  __INSTANCES__: Array<ModuleFederation>;
  __SHARE__: GlobalShareScopeMap;
  __MANIFEST_LOADING__: Record<string, Promise<ModuleInfo>>;
  __PRELOADED_MAP__: Map<string, boolean>;
}
declare global {
  var __FEDERATION__: Federation, __VMOK__: Federation, __GLOBAL_LOADING_REMOTE_ENTRY__: Record<string, undefined | Promise<RemoteEntryExports | void>>;
}
declare const getGlobalSnapshot: () => GlobalModuleInfo;
//#endregion
//#region ../runtime-core/dist/plugins/snapshot/SnapshotHandler.d.ts
//#region src/plugins/snapshot/SnapshotHandler.d.ts
declare class SnapshotHandler {
  loadingHostSnapshot: Promise<GlobalModuleInfo | void> | null;
  HostInstance: ModuleFederation;
  manifestCache: Map<string, Manifest>;
  hooks: PluginSystem<{
    beforeLoadRemoteSnapshot: AsyncHook<[{
      options: Options;
      moduleInfo: Remote;
    }], void>;
    loadSnapshot: AsyncWaterfallHook<{
      options: Options;
      moduleInfo: Remote;
      hostGlobalSnapshot: GlobalModuleInfo[string] | undefined;
      globalSnapshot: ReturnType<typeof getGlobalSnapshot>;
      remoteSnapshot?: GlobalModuleInfo[string] | undefined;
    }>;
    loadRemoteSnapshot: AsyncWaterfallHook<{
      options: Options;
      moduleInfo: Remote;
      manifestJson?: Manifest;
      manifestUrl?: string;
      remoteSnapshot: ModuleInfo;
      from: "global" | "manifest";
    }>;
    afterLoadSnapshot: AsyncWaterfallHook<{
      id?: string;
      host: ModuleFederation;
      options: Options;
      moduleInfo: Remote;
      remoteSnapshot: ModuleInfo;
    }>;
  }>;
  loaderHook: ModuleFederation['loaderHook'];
  manifestLoading: Record<string, Promise<ModuleInfo>>;
  constructor(HostInstance: ModuleFederation);
  loadRemoteSnapshotInfo({
    moduleInfo,
    id,
    expose
  }: {
    moduleInfo: Remote;
    id?: string;
    expose?: string;
  }): Promise<{
    remoteSnapshot: ModuleInfo;
    globalSnapshot: GlobalModuleInfo;
  }> | never;
  getGlobalRemoteInfo(moduleInfo: Remote): {
    hostGlobalSnapshot: ModuleInfo | undefined;
    globalSnapshot: ReturnType<typeof getGlobalSnapshot>;
    remoteSnapshot: GlobalModuleInfo[string] | undefined;
  };
  private getManifestJson;
} //#endregion
//#endregion
//#region ../runtime-core/dist/utils/load.d.ts
//#region src/utils/load.d.ts
declare function getRemoteEntry(params: {
  origin: ModuleFederation;
  remoteInfo: RemoteInfo;
  remoteEntryExports?: RemoteEntryExports | undefined;
  getEntryUrl?: (url: string) => string;
  _inErrorHandling?: boolean;
}): Promise<RemoteEntryExports | false | void>;
//#endregion
//#region ../runtime-core/dist/core.d.ts
//#region src/core.d.ts
declare class ModuleFederation {
  options: Options;
  hooks: PluginSystem<{
    beforeInit: SyncWaterfallHook<{
      userOptions: UserOptions;
      options: Options;
      origin: ModuleFederation;
      /**
       * @deprecated shareInfo will be removed soon, please use userOptions directly!
       */
      shareInfo: ShareInfos;
    }>;
    init: SyncHook<[{
      options: Options;
      origin: ModuleFederation;
    }], void>;
    beforeInitContainer: AsyncWaterfallHook<{
      shareScope: ShareScopeMap[string];
      initScope: InitScope;
      remoteEntryInitOptions: RemoteEntryInitOptions;
      remoteInfo: RemoteInfo;
      origin: ModuleFederation;
    }>;
    initContainer: AsyncWaterfallHook<{
      shareScope: ShareScopeMap[string];
      initScope: InitScope;
      remoteEntryInitOptions: RemoteEntryInitOptions;
      remoteInfo: RemoteInfo;
      remoteEntryExports: RemoteEntryExports;
      origin: ModuleFederation;
      id?: string;
      remoteSnapshot?: ModuleInfo;
    }>;
  }>;
  version: string;
  name: string;
  moduleCache: Map<string, Module$1>;
  snapshotHandler: SnapshotHandler;
  sharedHandler: SharedHandler;
  remoteHandler: RemoteHandler;
  shareScopeMap: ShareScopeMap;
  loaderHook: PluginSystem<{
    getModuleInfo: SyncHook<[{
      target: Record<string, any>;
      key: any;
    }], void | {
      value: any | undefined;
      key: string;
    }>;
    createScript: SyncHook<[{
      url: string;
      attrs?: Record<string, any>;
    }], CreateScriptHookReturn>;
    createLink: SyncHook<[{
      url: string;
      attrs?: Record<string, any>;
    }], void | HTMLLinkElement>;
    fetch: AsyncHook<[string, RequestInit], false | void | Promise<Response>>;
    loadEntryError: AsyncHook<[{
      getRemoteEntry: typeof getRemoteEntry;
      origin: ModuleFederation;
      remoteInfo: RemoteInfo;
      remoteEntryExports?: RemoteEntryExports | undefined;
      globalLoading: Record<string, Promise<void | RemoteEntryExports> | undefined>;
      uniqueKey: string;
    }], Promise<Promise<RemoteEntryExports | undefined> | undefined>>;
    getModuleFactory: AsyncHook<[{
      remoteEntryExports: RemoteEntryExports;
      expose: string;
      moduleInfo: RemoteInfo;
    }], Promise<(() => Promise<Module$1>) | undefined>>;
  }>;
  bridgeHook: PluginSystem<{
    beforeBridgeRender: SyncHook<[Record<string, any>], void | Record<string, any>>;
    afterBridgeRender: SyncHook<[Record<string, any>], void | Record<string, any>>;
    beforeBridgeDestroy: SyncHook<[Record<string, any>], void | Record<string, any>>;
    afterBridgeDestroy: SyncHook<[Record<string, any>], void | Record<string, any>>;
  }>;
  moduleInfo?: GlobalModuleInfo[string];
  constructor(userOptions: UserOptions);
  initOptions(userOptions: UserOptions): Options;
  loadShare<T>(pkgName: string, extraOptions?: {
    customShareInfo?: Partial<Shared>;
    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
  }): Promise<false | (() => T | undefined)>;
  loadShareSync<T>(pkgName: string, extraOptions?: {
    customShareInfo?: Partial<Shared>;
    from?: 'build' | 'runtime';
    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
  }): () => T | never;
  initializeSharing(shareScopeName?: string, extraOptions?: {
    initScope?: InitScope;
    from?: CallFrom;
    strategy?: Shared['strategy'];
  }): Array<Promise<void>>;
  initRawContainer(name: string, url: string, container: RemoteEntryExports): Module$1;
  loadRemote<T>(id: string, options?: {
    loadFactory?: boolean;
    from: CallFrom;
  }): Promise<T | null>;
  preloadRemote(preloadOptions: Array<PreloadRemoteArgs>): Promise<void>;
  initShareScopeMap(scopeName: string, shareScope: ShareScopeMap[string], extraOptions?: {
    hostShareScopeMap?: ShareScopeMap;
  }): void;
  formatOptions(globalOptions: Options, userOptions: UserOptions): Options;
  registerPlugins(plugins: UserOptions['plugins']): void;
  registerRemotes(remotes: Remote[], options?: {
    force?: boolean;
  }): void;
  registerShared(shared: UserOptions['shared']): void;
} //#endregion
//#endregion
//#region ../runtime-core/dist/module/index.d.ts
//#region src/module/index.d.ts
type ModuleOptions = ConstructorParameters<typeof Module$1>[0];
declare class Module$1 {
  remoteInfo: RemoteInfo;
  inited: boolean;
  initing: boolean;
  initPromise?: Promise<void>;
  remoteEntryExports?: RemoteEntryExports;
  lib: RemoteEntryExports | undefined;
  host: ModuleFederation;
  constructor({
    remoteInfo,
    host
  }: {
    remoteInfo: RemoteInfo;
    host: ModuleFederation;
  });
  getEntry(): Promise<RemoteEntryExports>;
  init(id?: string, remoteSnapshot?: ModuleInfo, rawInitScope?: InitScope): Promise<RemoteEntryExports>;
  get(id: string, expose: string, options?: {
    loadFactory?: boolean;
  }, remoteSnapshot?: ModuleInfo): Promise<any>;
  private wraperFactory;
} //#endregion
//#endregion
//#region src/runtime-plugins/dynamic-remote-type-hints-plugin.d.ts
declare function dynamicRemoteTypeHintsPlugin(): ModuleFederationRuntimePlugin;
export = dynamicRemoteTypeHintsPlugin;