@softarc/native-federation-orchestrator 4.0.0-RC1

package/types/lib/2.app/driver-ports/init/for-generating-import-map.d.ts

@@ -0,0 +1,2 @@
+import type { ImportMap } from '../../../1.domain/import-map/import-map.contract';
+export type ForGeneratingImportMap = () => Promise<ImportMap>;

package/types/lib/2.app/driver-ports/init/for-getting-remote-entries.port.d.ts

@@ -0,0 +1,3 @@
+import type { RemoteEntry } from '../../../1.domain/remote-entry/remote-entry.contract';
+import type { Manifest } from '../../../1.domain/remote-entry/manifest.contract';
+export type ForGettingRemoteEntries = (remotesOrManifestUrl: string | Manifest) => Promise<RemoteEntry[]>;

package/types/lib/2.app/driver-ports/init/for-processing-remote-entries.port.d.ts

@@ -0,0 +1,2 @@
+import type { RemoteEntry } from '../../../1.domain/remote-entry/remote-entry.contract';
+export type ForProcessingRemoteEntries = (remoteEntries: RemoteEntry[]) => Promise<RemoteEntry[]>;

package/types/lib/2.app/driver-ports/init/index.d.ts

@@ -0,0 +1,8 @@
+export * from './for-getting-remote-entries.port';
+export * from './for-processing-remote-entries.port';
+export * from './for-determining-shared-externals.port';
+export * from './for-generating-import-map';
+export * from './for-committing-changes.port';
+export * from './for-exposing-module-loader.port';
+export * from './flow.contract';
+export * from './drivers.contract';

package/types/lib/2.app/driver-ports/registry/for-managing-events.port.d.ts

@@ -0,0 +1,2 @@
+import type { NFEventRegistry } from '../../../1.domain/registry/event-registry.contract';
+export type ForManagingEvents = () => NFEventRegistry;

package/types/lib/2.app/driving-ports/driving.contract.d.ts

@@ -0,0 +1,16 @@
+import type { ForVersionChecking } from './for-version-checking.port';
+import type { ForBrowserTasks } from './for-browser-tasks';
+import type { ForProvidingManifest } from './for-providing-manifest.port';
+import type { ForProvidingRemoteEntries } from './for-providing-remote-entries.port';
+import type { ForRemoteInfoStorage } from './for-remote-info-storage.port';
+import type { ForScopedExternalsStorage } from './for-scoped-externals-storage.port';
+import type { ForSharedExternalsStorage } from './for-shared-externals-storage.port';
+export type DrivingContract = {
+    versionCheck: ForVersionChecking;
+    manifestProvider: ForProvidingManifest;
+    remoteEntryProvider: ForProvidingRemoteEntries;
+    remoteInfoRepo: ForRemoteInfoStorage;
+    scopedExternalsRepo: ForScopedExternalsStorage;
+    sharedExternalsRepo: ForSharedExternalsStorage;
+    browser: ForBrowserTasks;
+};

package/types/lib/2.app/driving-ports/for-browser-tasks.d.ts

@@ -0,0 +1,7 @@
+import type { ImportMap } from '../../1.domain/import-map/import-map.contract';
+export type ForBrowserTasks = {
+    setImportMapFn: (importMap: ImportMap, opt?: {
+        override?: boolean;
+    }) => Promise<ImportMap>;
+    importModule: (url: string) => Promise<unknown>;
+};

package/types/lib/2.app/driving-ports/for-providing-manifest.port.d.ts

@@ -0,0 +1,4 @@
+import type { Manifest } from '../../1.domain/remote-entry/manifest.contract';
+export type ForProvidingManifest = {
+    provide: (remotesOrManifestUrl: Manifest | string) => Promise<Manifest>;
+};

package/types/lib/2.app/driving-ports/for-providing-remote-entries.port.d.ts

@@ -0,0 +1,4 @@
+import type { RemoteEntry } from '../../1.domain/remote-entry/remote-entry.contract';
+export type ForProvidingRemoteEntries = {
+    provide: (remoteEntryUrl: string) => Promise<RemoteEntry>;
+};

package/types/lib/2.app/driving-ports/for-remote-info-storage.port.d.ts

@@ -0,0 +1,11 @@
+import type { RemoteInfo, RemoteName, Remotes } from '../../1.domain/remote/remote-info.contract';
+import type { Optional } from '../../utils/optional';
+export type ForRemoteInfoStorage = {
+    contains: (remoteName: RemoteName) => boolean;
+    tryGet: (remoteName: RemoteName) => Optional<RemoteInfo>;
+    remove: (remoteName: RemoteName) => ForRemoteInfoStorage;
+    tryGetModule: (remoteName: RemoteName, exposedModule: string) => Optional<string>;
+    addOrUpdate: (remoteName: string, remote: RemoteInfo) => ForRemoteInfoStorage;
+    getAll: () => Remotes;
+    commit: () => ForRemoteInfoStorage;
+};

package/types/lib/2.app/driving-ports/for-scoped-externals-storage.port.d.ts

@@ -0,0 +1,9 @@
+import type { RemoteName, ScopedExternal, ScopedExternals, ScopedVersion } from '../../1.domain';
+import type { Optional } from '../../utils/optional';
+export type ForScopedExternalsStorage = {
+    addExternal: (remoteName: RemoteName, external: string, version: ScopedVersion) => ForScopedExternalsStorage;
+    remove: (remoteName: RemoteName) => ForScopedExternalsStorage;
+    tryGet: (remoteName: string) => Optional<ScopedExternal>;
+    getAll: () => ScopedExternals;
+    commit: () => ForScopedExternalsStorage;
+};

package/types/lib/2.app/driving-ports/for-shared-externals-storage.port.d.ts

@@ -0,0 +1,13 @@
+import type { RemoteName, SharedExternal, shareScope } from '../../1.domain';
+import type { Optional } from '../../utils/optional';
+export type ForSharedExternalsStorage = {
+    tryGet: (external: string, shareScope?: string) => Optional<SharedExternal>;
+    getFromScope: (shareScope?: string) => shareScope;
+    getScopes: (o?: {
+        includeGlobal: boolean;
+    }) => string[];
+    scopeType: (shareScope?: string) => 'global' | 'strict' | 'shareScope';
+    removeFromAllScopes: (remoteName: RemoteName) => void;
+    addOrUpdate: (name: string, external: SharedExternal, shareScope?: string) => ForSharedExternalsStorage;
+    commit: () => ForSharedExternalsStorage;
+};

package/types/lib/2.app/driving-ports/for-version-checking.port.d.ts

@@ -0,0 +1,6 @@
+export type ForVersionChecking = {
+    isValidSemver: (version: string) => boolean;
+    isCompatible: (version: string, versionRange: string) => boolean;
+    compare: (versionA: string, versionB: string) => number;
+    smallestVersion: (versionRange: string) => string;
+};

package/types/lib/2.app/driving-ports/index.d.ts

@@ -0,0 +1,8 @@
+export * from './for-version-checking.port';
+export * from './for-browser-tasks';
+export * from './for-providing-manifest.port';
+export * from './for-providing-remote-entries.port';
+export * from './for-remote-info-storage.port';
+export * from './for-scoped-externals-storage.port';
+export * from './for-shared-externals-storage.port';
+export * from './driving.contract';

package/types/lib/2.app/flows/audit/externals-audit.d.ts

@@ -0,0 +1,4 @@
+import type { LoggingConfig, ModeConfig } from '../../config';
+import type { DrivingContract } from '../../driving-ports/driving.contract';
+import type { ForAuditingExternals } from '../../driver-ports/audit/for-auditing-externals.port';
+export declare function createExternalsAudit(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'versionCheck' | 'sharedExternalsRepo' | 'scopedExternalsRepo'>): ForAuditingExternals;

package/types/lib/2.app/flows/dynamic-init/convert-to-import-map.d.ts

@@ -0,0 +1,3 @@
+import type { LoggingConfig } from '../../config/log.contract';
+import type { ForConvertingToImportMap } from '../../driver-ports/dynamic-init/for-converting-to-import-map';
+export declare function createConvertToImportMap({ log }: LoggingConfig): ForConvertingToImportMap;

package/types/lib/2.app/flows/dynamic-init/get-remote-entry.d.ts

@@ -0,0 +1,5 @@
+import type { DrivingContract } from '../../driving-ports/driving.contract';
+import type { LoggingConfig } from '../../config/log.contract';
+import type { ModeConfig } from '../../config/mode.contract';
+import type { ForGettingRemoteEntry } from '../../driver-ports/dynamic-init/for-getting-remote-entry.port';
+export declare function createGetRemoteEntry(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'remoteEntryProvider' | 'remoteInfoRepo'>): ForGettingRemoteEntry;

package/types/lib/2.app/flows/dynamic-init/update-cache.d.ts

@@ -0,0 +1,5 @@
+import type { ForUpdatingCache } from '../../driver-ports/dynamic-init/for-updating-cache';
+import type { DrivingContract } from '../../driving-ports/driving.contract';
+import type { LoggingConfig } from '../../config/log.contract';
+import type { ModeConfig } from '../../config/mode.contract';
+export declare function createUpdateCache(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'remoteInfoRepo' | 'sharedExternalsRepo' | 'scopedExternalsRepo' | 'versionCheck'>): ForUpdatingCache;

package/types/lib/2.app/flows/init/commit-changes.d.ts

@@ -0,0 +1,4 @@
+import type { DrivingContract } from '../../driving-ports/driving.contract';
+import type { ForCommittingChanges } from '../../driver-ports/init/for-committing-changes.port';
+import type { LoggingConfig } from '../../config';
+export declare function createCommitChanges(config: LoggingConfig, ports: Pick<DrivingContract, 'remoteInfoRepo' | 'scopedExternalsRepo' | 'sharedExternalsRepo' | 'browser'>): ForCommittingChanges;

package/types/lib/2.app/flows/init/determine-shared-externals.d.ts

@@ -0,0 +1,5 @@
+import type { ForDeterminingSharedExternals } from '../../driver-ports/init/for-determining-shared-externals.port';
+import type { DrivingContract } from '../../driving-ports/driving.contract';
+import type { LoggingConfig } from '../../config/log.contract';
+import type { ModeConfig } from '../../config/mode.contract';
+export declare function createDetermineSharedExternals(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'versionCheck' | 'sharedExternalsRepo'>): ForDeterminingSharedExternals;

package/types/lib/2.app/flows/init/expose-module-loader.d.ts

@@ -0,0 +1,4 @@
+import type { DrivingContract } from '../../driving-ports/driving.contract';
+import type { ForExposingModuleLoader } from '../../driver-ports/init/for-exposing-module-loader.port';
+import type { LoggingConfig } from '../../config/log.contract';
+export declare function createExposeModuleLoader(config: LoggingConfig, ports: Pick<DrivingContract, 'remoteInfoRepo' | 'browser'>): ForExposingModuleLoader;

package/types/lib/2.app/flows/init/generate-import-map.d.ts

@@ -0,0 +1,5 @@
+import type { ForGeneratingImportMap } from '../../driver-ports/init/for-generating-import-map';
+import type { DrivingContract } from '../../driving-ports/driving.contract';
+import type { LoggingConfig } from '../../config/log.contract';
+import type { ModeConfig } from '../../config/mode.contract';
+export declare function createGenerateImportMap(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'remoteInfoRepo' | 'scopedExternalsRepo' | 'sharedExternalsRepo'>): ForGeneratingImportMap;

package/types/lib/2.app/flows/init/get-remote-entries.d.ts

@@ -0,0 +1,6 @@
+import type { ForGettingRemoteEntries } from '../../driver-ports/init/for-getting-remote-entries.port';
+import type { DrivingContract } from '../../driving-ports/driving.contract';
+import type { LoggingConfig } from '../../config/log.contract';
+import type { ModeConfig } from '../../config/mode.contract';
+import type { HostConfig } from '../../config/host.contract';
+export declare function createGetRemoteEntries(config: LoggingConfig & ModeConfig & HostConfig, ports: Pick<DrivingContract, 'remoteEntryProvider' | 'manifestProvider' | 'remoteInfoRepo'>): ForGettingRemoteEntries;

package/types/lib/2.app/flows/init/process-remote-entries.d.ts

@@ -0,0 +1,5 @@
+import type { ForProcessingRemoteEntries } from '../../driver-ports/init/for-processing-remote-entries.port';
+import type { DrivingContract } from '../../driving-ports/driving.contract';
+import type { LoggingConfig } from '../../config/log.contract';
+import type { ModeConfig } from '../../config/mode.contract';
+export declare function createProcessRemoteEntries(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'remoteInfoRepo' | 'sharedExternalsRepo' | 'scopedExternalsRepo' | 'versionCheck'>): ForProcessingRemoteEntries;

package/types/lib/2.app/flows/registry/setup-registry.d.ts

@@ -0,0 +1,3 @@
+import type { ForManagingEvents } from '../../driver-ports/registry/for-managing-events.port';
+import type { NFEventRegistryConfig } from '../../config/registry.contract';
+export declare function createRegistry(opts: NFEventRegistryConfig): ForManagingEvents;

package/types/lib/3.adapters/browser/browser.d.ts

@@ -0,0 +1,4 @@
+import type { ForBrowserTasks } from '../../2.app/driving-ports/for-browser-tasks';
+import type { ImportMapConfig } from '../../2.app/config/import-map.contract';
+declare const createBrowser: (config: ImportMapConfig) => ForBrowserTasks;
+export { createBrowser };

package/types/lib/3.adapters/checks/version.check.d.ts

@@ -0,0 +1,3 @@
+import type { ForVersionChecking } from '../../2.app/driving-ports/for-version-checking.port';
+declare const createVersionCheck: () => ForVersionChecking;
+export { createVersionCheck };

package/types/lib/3.adapters/http/manifest-provider.d.ts

@@ -0,0 +1,3 @@
+import type { ForProvidingManifest } from '../../2.app/driving-ports/for-providing-manifest.port';
+declare const createManifestProvider: () => ForProvidingManifest;
+export { createManifestProvider };

package/types/lib/3.adapters/http/remote-entry-provider.d.ts

@@ -0,0 +1,3 @@
+import type { ForProvidingRemoteEntries } from '../../2.app/driving-ports/for-providing-remote-entries.port';
+declare const createRemoteEntryProvider: () => ForProvidingRemoteEntries;
+export { createRemoteEntryProvider };

package/types/lib/3.adapters/storage/remote-info.repository.d.ts

@@ -0,0 +1,4 @@
+import type { StorageConfig } from '../../2.app/config/storage.contract';
+import type { ForRemoteInfoStorage } from '../../2.app/driving-ports/for-remote-info-storage.port';
+declare const createRemoteInfoRepository: (config: StorageConfig) => ForRemoteInfoStorage;
+export { createRemoteInfoRepository };

package/types/lib/3.adapters/storage/scoped-externals.repository.d.ts

@@ -0,0 +1,4 @@
+import type { StorageConfig } from '../../2.app/config/storage.contract';
+import type { ForScopedExternalsStorage } from '../../2.app/driving-ports/for-scoped-externals-storage.port';
+declare const createScopedExternalsRepository: (config: StorageConfig) => ForScopedExternalsStorage;
+export { createScopedExternalsRepository };

package/types/lib/3.adapters/storage/shared-externals.repository.d.ts

@@ -0,0 +1,4 @@
+import type { StorageConfig } from '../../2.app/config/storage.contract';
+import type { ForSharedExternalsStorage } from '../../2.app/driving-ports/for-shared-externals-storage.port';
+declare const createSharedExternalsRepository: (config: StorageConfig) => ForSharedExternalsStorage;
+export { createSharedExternalsRepository };

package/types/lib/4.config/host/host.config.d.ts

@@ -0,0 +1,2 @@
+import type { HostConfig, HostOptions } from '../../2.app/config/host.contract';
+export declare const createHostConfig: (override: Partial<HostOptions>) => HostConfig;

package/types/lib/4.config/import-map/import-map.config.d.ts

@@ -0,0 +1,2 @@
+import type { ImportMapConfig, ImportMapOptions } from '../../2.app/config/import-map.contract';
+export declare const createImportMapConfig: (o: Partial<ImportMapOptions>) => ImportMapConfig;

package/types/lib/4.config/import-map/index.d.ts

@@ -0,0 +1,3 @@
+export * from './use-import-shim';
+export * from './use-default';
+export * from './replace-in-dom';

package/types/lib/4.config/import-map/replace-in-dom.d.ts

@@ -0,0 +1,2 @@
+import type { SetImportMap } from '../../2.app/config/import-map.contract';
+export declare const replaceInDOM: (mapType: string) => SetImportMap;

package/types/lib/4.config/import-map/use-default.d.ts

@@ -0,0 +1,3 @@
+import type { ImportMapConfig } from '../../2.app/config/import-map.contract';
+declare const useDefaultImportMap: () => ImportMapConfig;
+export { useDefaultImportMap };

package/types/lib/4.config/import-map/use-import-shim.d.ts

@@ -0,0 +1,5 @@
+import type { ImportMapConfig } from '../../2.app/config/import-map.contract';
+declare const useShimImportMap: (cfg?: {
+    shimMode: boolean;
+}) => ImportMapConfig;
+export { useShimImportMap };

package/types/lib/4.config/logging/console.logger.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from '../../2.app/config/log.contract';
+declare const consoleLogger: Logger;
+export { consoleLogger };

package/types/lib/4.config/logging/index.d.ts

@@ -0,0 +1,2 @@
+export { consoleLogger } from './console.logger';
+export { noopLogger } from './noop.logger';

package/types/lib/4.config/logging/log.config.d.ts

@@ -0,0 +1,2 @@
+import type { LoggingConfig, LoggingOptions } from '../../2.app/config/log.contract';
+export declare const createLogConfig: ({ logger, logLevel }: LoggingOptions) => LoggingConfig;

package/types/lib/4.config/logging/log.handler.d.ts

@@ -0,0 +1,3 @@
+import { type LogType, type LogHandler, type Logger } from '../../2.app/config/log.contract';
+declare const createLogHandler: (logger: Logger, logLevel: LogType) => LogHandler;
+export { createLogHandler };

package/types/lib/4.config/logging/noop.logger.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from '../../2.app/config/log.contract';
+declare const noopLogger: Logger;
+export { noopLogger };

package/types/lib/4.config/mode/caching.profile.d.ts

@@ -0,0 +1,2 @@
+import type { ModeProfileConfig } from '../../2.app/config/mode.contract';
+export declare const cachingProfile: ModeProfileConfig;

package/types/lib/4.config/mode/default.profile.d.ts

@@ -0,0 +1,2 @@
+import type { ModeProfileConfig } from '../../2.app/config/mode.contract';
+export declare const defaultProfile: ModeProfileConfig;

package/types/lib/4.config/mode/index.d.ts

@@ -0,0 +1,2 @@
+export { defaultProfile } from './default.profile';
+export { cachingProfile } from './caching.profile';

package/types/lib/4.config/mode/mode.config.d.ts

@@ -0,0 +1,2 @@
+import type { ModeConfig, ModeOptions } from '../../2.app/config/mode.contract';
+export declare const createModeConfig: (override: ModeOptions) => ModeConfig;

package/types/lib/4.config/storage/global-this.storage.d.ts

@@ -0,0 +1,3 @@
+import { type StorageEntryCreator } from '../../2.app/config/storage.contract';
+declare const globalThisStorageEntry: StorageEntryCreator;
+export { globalThisStorageEntry };

package/types/lib/4.config/storage/index.d.ts

@@ -0,0 +1,3 @@
+export { globalThisStorageEntry } from './global-this.storage';
+export { localStorageEntry } from './local.storage';
+export { sessionStorageEntry } from './session.storage';

package/types/lib/4.config/storage/local.storage.d.ts

@@ -0,0 +1,3 @@
+import type { StorageEntryCreator } from '../../2.app/config/storage.contract';
+declare const localStorageEntry: StorageEntryCreator;
+export { localStorageEntry };

package/types/lib/4.config/storage/session.storage.d.ts

@@ -0,0 +1,3 @@
+import type { StorageEntryCreator } from '../../2.app/config/storage.contract';
+declare const sessionStorageEntry: StorageEntryCreator;
+export { sessionStorageEntry };

package/types/lib/4.config/storage/storage.config.d.ts

@@ -0,0 +1,2 @@
+import type { StorageConfig, StorageOptions } from '../../2.app/config/storage.contract';
+export declare const createStorageConfig: (override: StorageOptions) => StorageConfig;

package/types/lib/5.di/config.factory.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigContract, NFOptions } from '../2.app/config/config.contract';
+export declare const createConfigHandlers: (overrides: NFOptions) => ConfigContract;

package/types/lib/5.di/driving.factory.d.ts

@@ -0,0 +1,6 @@
+import type { DrivingContract } from '../2.app/driving-ports/driving.contract';
+import type { ConfigContract } from '../2.app/config/config.contract';
+export declare const createDriving: (config: ConfigContract) => {
+    adapters: DrivingContract;
+    config: ConfigContract;
+};

package/types/lib/5.di/flows/dynamic-init.factory.d.ts

@@ -0,0 +1,14 @@
+import type { DynamicInitFlow } from '../../2.app/driver-ports/dynamic-init/flow.contract';
+import type { FLOW_FACTORY } from '../../2.app/driver-ports/flow-factory.contract';
+import type { DynamicInitDriversContract } from '../../audit.index';
+import type { DrivingContract } from '../../2.app/driving-ports/driving.contract';
+import type { ConfigContract } from '../../2.app/config/config.contract';
+export declare const createDynamicInitDrivers: ({ config, adapters, }: {
+    config: ConfigContract;
+    adapters: DrivingContract;
+}) => DynamicInitDriversContract;
+export declare const DYNAMIC_INIT_FLOW_FACTORY: ({ config, adapters, }: {
+    config: ConfigContract;
+    adapters: DrivingContract;
+}) => FLOW_FACTORY<DynamicInitDriversContract>;
+export declare const createDynamicInitFlow: ({ flow, adapters, config, }: FLOW_FACTORY<DynamicInitDriversContract>) => DynamicInitFlow;

package/types/lib/5.di/flows/init.factory.d.ts

@@ -0,0 +1,14 @@
+import type { FLOW_FACTORY } from '../../2.app/driver-ports/flow-factory.contract';
+import type { InitDriversContract } from '../../2.app/driver-ports/init/drivers.contract';
+import type { InitFlow } from '../../2.app/driver-ports/init/flow.contract';
+import type { DrivingContract } from '../../2.app/driving-ports/driving.contract';
+import type { ConfigContract } from '../../2.app/config/config.contract';
+export declare const createInitDrivers: ({ config, adapters, }: {
+    config: ConfigContract;
+    adapters: DrivingContract;
+}) => InitDriversContract;
+export declare const INIT_FLOW_FACTORY: ({ config, adapters, }: {
+    config: ConfigContract;
+    adapters: DrivingContract;
+}) => FLOW_FACTORY<InitDriversContract>;
+export declare const createInitFlow: ({ flow, adapters, config, }: FLOW_FACTORY<InitDriversContract>) => InitFlow;

package/types/lib/6.mocks/handlers/log.handler.d.ts

@@ -0,0 +1,2 @@
+import type { LogHandler, LogType } from '../../2.app/config/log.contract';
+export declare const createMockLogHandler: (level?: LogType) => jest.Mocked<LogHandler>;

package/types/lib/audit.index.d.ts

@@ -0,0 +1,2 @@
+export * from './2.app/driver-ports/dynamic-init';
+export * from './2.app/flows/audit/externals-audit';

package/types/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { initFederation } from './init-federation';
+export { NFError } from './native-federation.error';
+export { LoadRemoteModule, NativeFederationResult } from './init-federation.contract';
+export { createConfigHandlers } from './5.di/config.factory';
+export { createDriving } from './5.di/driving.factory';
+export { createDynamicInitDrivers, DYNAMIC_INIT_FLOW_FACTORY, createDynamicInitFlow, } from './5.di/flows/dynamic-init.factory';
+export { createInitDrivers, INIT_FLOW_FACTORY, createInitFlow } from './5.di/flows/init.factory';

package/types/lib/init-federation.contract.d.ts

@@ -0,0 +1,15 @@
+import type { ConfigContract } from './2.app/config/config.contract';
+import type { DrivingContract } from './2.app/driving-ports/driving.contract';
+import type { DynamicInitResult } from './2.app/driver-ports/dynamic-init/flow.contract';
+export type LoadRemoteModule<TModule = unknown> = (remoteName: string, exposedModule: string) => Promise<TModule>;
+export type NativeFederationResult = DynamicInitResult<{
+    config: ConfigContract;
+    adapters: DrivingContract;
+    loadRemoteModule: LoadRemoteModule;
+    remote: <TModule = unknown>(remoteName: string) => {
+        loadModule: (exposedModule: string) => Promise<TModule>;
+    };
+    as: <TModule = unknown>() => {
+        loadRemoteModule: LoadRemoteModule<TModule>;
+    };
+}>;

package/types/lib/init-federation.d.ts

@@ -0,0 +1,4 @@
+import type { NativeFederationResult } from './init-federation.contract';
+import type { NFOptions } from './2.app/config/config.contract';
+declare const initFederation: (remotesOrManifestUrl: string | Record<string, string>, options?: NFOptions) => Promise<NativeFederationResult>;
+export { initFederation };

package/types/lib/native-federation.error.d.ts

@@ -0,0 +1,4 @@
+declare class NFError extends Error {
+    constructor(message: string, cause?: Error);
+}
+export { NFError };

package/types/lib/options.index.d.ts

@@ -0,0 +1,5 @@
+export * from './2.app/config';
+export * from './4.config/logging';
+export * from './4.config/storage';
+export * from './4.config/import-map';
+export * from './4.config/mode';

package/types/lib/registry.index.d.ts

@@ -0,0 +1,4 @@
+export * from './1.domain/registry';
+export { NFEventRegistryConfig, NFEventRegistryOptions } from './2.app/config/registry.contract';
+export { ForManagingEvents } from './2.app/driver-ports/registry/for-managing-events.port';
+export { createRegistry } from './2.app/flows/registry/setup-registry';

package/types/lib/sdk.index.d.ts

@@ -0,0 +1,8 @@
+export * from './1.domain';
+export * from './2.app/driving-ports';
+export * from './2.app/driver-ports/init';
+export * from './2.app/driver-ports/dynamic-init';
+export { FLOW_FACTORY } from './2.app/driver-ports/flow-factory.contract';
+export { Optional } from './utils/optional';
+export * as _path from './utils/path';
+export { cloneEntry } from './utils/clone-entry';

package/types/lib/utils/clone-entry.d.ts

@@ -0,0 +1,4 @@
+import type { StorageEntryKey } from '../2.app/config/storage.contract';
+type CloneEntry = <T>(name: StorageEntryKey, raw: T) => T;
+declare const cloneEntry: CloneEntry;
+export { CloneEntry, cloneEntry };

package/types/lib/utils/optional.d.ts

@@ -0,0 +1,13 @@
+export declare class Optional<T> {
+    private item?;
+    private constructor();
+    static of<T>(item?: T): Optional<T>;
+    static empty<U>(): Optional<U>;
+    isPresent(): boolean;
+    set<U>(other: U): Optional<U>;
+    ifPresent(callback: (_: T) => void): void;
+    map<U>(callback: (_: NonNullable<T>) => U | Optional<U>): Optional<U>;
+    orElse(other: Required<T>): NonNullable<T>;
+    orThrow(error: Error | string | (() => Error)): NonNullable<T>;
+    get(): T | undefined;
+}

package/types/lib/utils/path.d.ts

@@ -0,0 +1,3 @@
+declare function join(pathA: string, pathB: string): string;
+declare function getScope(path: string): string;
+export { join, getScope };

package/types/quickstart.d.ts

@@ -0,0 +1 @@
+import 'es-module-shims';