@equinor/fusion-framework-react 8.0.0-next.0 → 8.0.0

package/dist/types/Framework.d.ts

@@ -1,7 +1,44 @@
 import type { FrameworkConfigurator } from '@equinor/fusion-framework';
 import { type PropsWithChildren, type ReactNode } from 'react';
 import type { ModulesInstance } from '@equinor/fusion-framework-module';
+/**
+ * Callback invoked during framework initialisation to configure modules.
+ *
+ * @param configurator - The framework configurator instance to apply settings to.
+ */
 type ConfigureCallback = (configurator: FrameworkConfigurator) => void;
+/**
+ * Declarative React component that initialises a Fusion Framework instance
+ * and provides it to descendant components via context.
+ *
+ * @remarks
+ * Internally calls {@link createFrameworkProvider} and wraps the lazy-loaded
+ * provider in a `<Suspense>` boundary. This is the recommended high-level
+ * component for portal / host applications that need to bootstrap the
+ * framework inside a React tree.
+ *
+ * @param props.configure - Callback that receives a {@link FrameworkConfigurator}
+ *   for registering modules and configuration.
+ * @param props.fallback - React node shown while the framework is initialising.
+ * @param props.parent - Optional parent module instance to inherit configuration from.
+ * @param props.children - Application content rendered after initialisation.
+ *
+ * @example
+ * ```tsx
+ * import { Framework } from '@equinor/fusion-framework-react';
+ *
+ * const App = () => (
+ *   <Framework
+ *     configure={(configurator) => {
+ *       configurator.http.configureClient('my-api', { baseUri: 'https://api.example.com' });
+ *     }}
+ *     fallback={<span>Loading…</span>}
+ *   >
+ *     <MyApp />
+ *   </Framework>
+ * );
+ * ```
+ */
 export declare const Framework: (props: PropsWithChildren<{
     readonly configure: ConfigureCallback;
     readonly fallback: NonNullable<ReactNode> | null;

package/dist/types/app/index.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Application React hooks.
+ *
+ * @remarks
+ * Available via the `@equinor/fusion-framework-react/app` sub-entry-point.
+ * Provides hooks and types for querying application manifests, observing
+ * the currently active app, and accessing app-level modules.
+ *
+ * @module
+ */
 export type { AppConfig, AppManifest, AppType, IApp } from '@equinor/fusion-framework-module-app';
 export { useCurrentApp } from './useCurrentApp';
 export { useCurrentAppModule } from './useCurrentAppModule';

package/dist/types/app/useAppProvider.d.ts

@@ -1,8 +1,17 @@
 import type { FusionModulesInstance } from '@equinor/fusion-framework';
 import type { AppModule } from '@equinor/fusion-framework-module-app';
 /**
- * React Hook - get appProvider interface
- * @returns framework AppModule
+ * React hook that returns the App module provider from the framework.
+ *
+ * @returns The app module instance (`AppModule`) for querying and managing
+ *   application manifests and the currently active app.
+ * @throws {Error} If the `AppModule` is not configured in the framework.
+ *
+ * @example
+ * ```ts
+ * const provider = useAppProvider();
+ * provider.getAppManifests().subscribe(console.log);
+ * ```
  */
 export declare const useAppProvider: () => FusionModulesInstance<[AppModule]>["app"];
 export default useAppProvider;

package/dist/types/app/useApps.d.ts

@@ -5,9 +5,23 @@ type UseAppsArgs = {
     filterByCurrentUser?: boolean;
 };
 /**
- * React Hook - Get apps from framework
- * @param args Object with filterByCurrentUser: boolean
- * @returns Object {apps, isLoading, error} where apps is Array of ApplicationManifest, isLoading is a boolean on observable complete
+ * React hook that retrieves available application manifests from the framework.
+ *
+ * @param args - Optional filtering options.
+ * @param args.filterByCurrentUser - When `true`, only apps accessible to the
+ *   current user are returned.
+ * @returns An object containing:
+ *   - `apps` — Array of {@link AppManifest} objects, or `undefined` while loading.
+ *   - `isLoading` — `true` until the observable completes.
+ *   - `error` — Any error emitted by the underlying observable.
+ *
+ * @example
+ * ```tsx
+ * const { apps, isLoading, error } = useApps({ filterByCurrentUser: true });
+ * if (isLoading) return <Spinner />;
+ * return <AppList apps={apps} />;
+ * ```
+ *
  * @since 7.1.1
  */
 export declare const useApps: (args?: UseAppsArgs) => {

package/dist/types/app/useCurrentApp.d.ts

@@ -1,12 +1,33 @@
 import type { AnyModule } from '@equinor/fusion-framework-module';
 import type { ConfigEnvironment, CurrentApp } from '@equinor/fusion-framework-module-app';
 /**
- * Observers the stream of current app and return the latest application
+ * React hook that observes and returns the currently active application.
  *
- * __Warning:__ type hint templates are only hints, this does not check if the modules are actually enabled!
+ * @remarks
+ * Subscribes to the `current$` stream on the App module and returns the
+ * latest value together with helpers to change or clear the active app.
  *
- * @template TModule type hint modules which the application has configured
- * @template TEnv type hint what kind of environment config the application has
+ * **Warning:** The template parameters are compile-time hints only — the
+ * hook does not validate that the specified modules are actually enabled.
+ *
+ * @template TModules - Tuple of module types the current app is expected to
+ *   have configured (type-hint only).
+ * @template TEnv - Expected environment configuration shape (type-hint only).
+ *
+ * @returns An object containing:
+ *   - `currentApp` — The current {@link CurrentApp} instance, `null` when
+ *     explicitly cleared, or `undefined` while loading.
+ *   - `setCurrentApp(appKey)` — Sets the active app by its key.
+ *   - `clearCurrentApp()` — Clears the currently active app.
+ *   - `error` — Any error emitted by the observable.
+ *
+ * @throws {Error} If the `AppModule` is not configured in the framework.
+ *
+ * @example
+ * ```tsx
+ * const { currentApp, setCurrentApp } = useCurrentApp();
+ * return <button onClick={() => setCurrentApp('my-app')}>{currentApp?.manifest?.name}</button>;
+ * ```
  */
 export declare const useCurrentApp: <TModules extends Array<AnyModule> = [], TEnv extends ConfigEnvironment = ConfigEnvironment>() => {
     currentApp?: CurrentApp<TModules, TEnv> | null;

package/dist/types/app/useCurrentAppModule.d.ts

@@ -1,14 +1,20 @@
 import type { AppModules, AppModulesInstance } from '@equinor/fusion-framework-module-app';
 import type { ModuleKey, AnyModule, ModuleTypes, ModuleType } from '@equinor/fusion-framework-module';
 /**
- * Retrieves the current app module based on the provided module key.
- * @template TType - The type of the module.
- * @template TKey - The type of the module key.
- * @param {TKey} moduleKey - The key of the module to retrieve.
- * @returns {AnyModule | null | undefined} - The current app module or null if not found.
+ * React hook that retrieves a specific module from the current application.
+ *
+ * @template TType - The expected module type.
+ * @template TKey - The module key used for look-up.
+ * @param moduleKey - The key of the module to retrieve.
+ * @returns An object containing:
+ *   - `module` — The resolved module instance, `null` when no app is
+ *     selected, or `undefined` if the app does not enable the requested module.
+ *   - `error` — Any error emitted during initialisation.
+ *   - `complete` — `true` when the observable has completed.
+ *
  * @remarks
- *  - when module is null, there are no current selected application
- *  - when undefined is, the application has not enabled the requested module
+ * - A `null` value means no application is currently selected.
+ * - An `undefined` value means the application has not enabled the requested module.
  */
 export declare const useCurrentAppModule: <TType extends AnyModule | unknown = unknown, TKey extends string = ModuleKey<ModuleTypes<AppModules<[TType]>>>>(moduleKey: TKey) => {
     module?: (TType extends AnyModule ? ModuleType<TType> : AppModulesInstance[Extract<keyof AppModulesInstance, TKey>]) | null;

package/dist/types/app/useCurrentAppModules.d.ts

@@ -1,12 +1,22 @@
 import type { AppModulesInstance } from '@equinor/fusion-framework-module-app';
 import type { AnyModule } from '@equinor/fusion-framework-module';
 /**
- * Observers the stream of current app initialized modules
+ * React hook that observes the initialised modules of the current application.
  *
- * __Warning:__ type hint templates are only hints, this does not check if the modules are actually enabled!
+ * @remarks
+ * Subscribes to the `instance$` stream of the current app and returns the
+ * resolved module instances.
  *
- * @template TModule type hint modules which the application has configured
- * @returns the observable instance of initialized modules of the application
+ * **Warning:** The template parameter is a compile-time hint only — the
+ * hook does not validate that the specified modules are actually enabled.
+ *
+ * @template TModules - Tuple of module types expected on the current app
+ *   (type-hint only).
+ * @returns An object containing:
+ *   - `modules` — The initialised {@link AppModulesInstance}, `null` when no
+ *     app is selected, or `undefined` while loading.
+ *   - `error` — Any error emitted during initialisation.
+ *   - `complete` — `true` when the observable has completed.
  */
 export declare const useCurrentAppModules: <TModules extends Array<AnyModule> = []>() => {
     modules?: AppModulesInstance<TModules> | null;

package/dist/types/context/index.d.ts

@@ -1,2 +1,12 @@
+/**
+ * Context React hooks.
+ *
+ * @remarks
+ * Available via the `@equinor/fusion-framework-react/context` sub-entry-point.
+ * Re-exports the context module’s React API and adds a convenience
+ * `useCurrentContext` hook that resolves the module from the framework.
+ *
+ * @module
+ */
 export * from '@equinor/fusion-framework-react-module-context';
 export { useCurrentContext } from './useCurrentContext';

package/dist/types/context/useCurrentContext.d.ts

@@ -1,3 +1,19 @@
+/**
+ * React hook that returns the currently selected Fusion context.
+ *
+ * @remarks
+ * This is a convenience wrapper that resolves the context module from the
+ * framework instance and delegates to the underlying
+ * `useCurrentContext` hook from `@equinor/fusion-framework-react-module-context`.
+ *
+ * @returns The current context state as defined by the context module.
+ *
+ * @example
+ * ```ts
+ * const { currentContext } = useCurrentContext();
+ * console.log(currentContext?.id);
+ * ```
+ */
 export declare const useCurrentContext: () => {
     currentContext: import("@equinor/fusion-framework-module-context").ContextItem | null | undefined;
     setCurrentContext: (entry?: import("@equinor/fusion-framework-module-context").ContextItem | string | null) => void | Promise<import("@equinor/fusion-framework-module-context").ContextItem<Record<string, unknown>> | null>;

package/dist/types/context.d.ts

@@ -1,5 +1,4 @@
 import type { Fusion } from '@equinor/fusion-framework';
-export declare const context: import("react").Context<Fusion<any> | null>;
 /**
  * Component for providing framework.
  *

package/dist/types/create-framework-provider.d.ts

@@ -2,20 +2,41 @@ import type React from 'react';
 import { FrameworkConfigurator } from '@equinor/fusion-framework';
 import type { AnyModule, ModulesInstanceType } from '@equinor/fusion-framework-module';
 /**
- * Create a framework provider for react.
+ * Creates a lazy-loaded React component that initialises a Fusion Framework
+ * instance and exposes it via context providers.
  *
- * This function is for providers of framework, like a portal.
+ * @remarks
+ * This is the low-level factory used by the {@link Framework} component.
+ * Call it when you need fine-grained control over memoisation or when you
+ * want to embed the provider in a custom `<Suspense>` boundary.
+ *
+ * The returned component is created with `React.lazy`, so it **must** be
+ * rendered inside a `<Suspense>` boundary.
+ *
+ * @template TModules - Tuple of additional module types to register.
+ * @template TRef - Type of the optional parent module-instance reference.
+ *
+ * @param cb - Callback that receives a {@link FrameworkConfigurator} (and an
+ *   optional parent ref) for registering modules and configuration.
+ * @param ref - Optional parent module instance to inherit configuration from.
+ * @returns A `React.lazy` component that provides the initialised framework
+ *   to its children.
  *
- * @param configurator - callback for configuring modules
  * @example
  * ```tsx
- * const config: FrameworkConfigurator = (config) => {}
+ * import { createFrameworkProvider } from '@equinor/fusion-framework-react';
+ *
  * const Portal = () => {
- *   const Framework = createFrameworkProvider(config);
+ *   const FrameworkProvider = createFrameworkProvider((config) => {
+ *     config.http.configureClient('my-api', { baseUri: 'https://api.example.com' });
+ *   });
+ *
  *   return (
- *      <Suspense fallback={<span>loading...</span>}>
- *          <Framework>{children}</Framework>
- *      </Suspense>
+ *     <Suspense fallback={<span>Loading…</span>}>
+ *       <FrameworkProvider>
+ *         <App />
+ *       </FrameworkProvider>
+ *     </Suspense>
  *   );
  * };
  * ```

package/dist/types/feature-flag/index.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Feature-flag React hooks.
+ *
+ * @remarks
+ * Available via the `@equinor/fusion-framework-react/feature-flag` sub-entry-point.
+ * Provides hooks to read, toggle, and observe feature flags at the
+ * framework or application level.
+ *
+ * @module
+ */
 export { useFeature } from './useFeature';
 export { useFeatures } from './useFeatures';
 export { useCurrentAppFeatures } from './useCurrentAppFeatures';

package/dist/types/feature-flag/useCurrentAppFeatures.d.ts

@@ -1,6 +1,16 @@
 import { type UseFeaturesResult } from './useFeatures';
 /**
- * Custom hook that returns the current app features and provides a function to toggle a feature.
- * @returns An object containing the current app features, a function to toggle a feature, and any error that occurred.
+ * React hook that returns feature flags registered on the current application.
+ *
+ * @returns A {@link UseFeaturesResult} containing:
+ *   - `features` — Array of feature flags for the current app.
+ *   - `toggleFeature(key, enable?)` — Toggles a feature flag on or off.
+ *   - `error` — Any error from the feature-flag or app-module streams.
+ *
+ * @example
+ * ```ts
+ * const { features, toggleFeature } = useCurrentAppFeatures();
+ * toggleFeature('dark-mode', true);
+ * ```
  */
 export declare const useCurrentAppFeatures: () => UseFeaturesResult;

package/dist/types/feature-flag/useFeature.d.ts

@@ -1,19 +1,36 @@
 import type { IFeatureFlag, IFeatureFlagProvider } from '@equinor/fusion-framework-module-feature-flag';
+/**
+ * Return type of the {@link useFeature} hook.
+ *
+ * @template T - Value type carried by the feature flag.
+ */
 export interface UseFeatureResult<T> {
+    /** The resolved feature flag, or `undefined` while loading. */
     feature?: IFeatureFlag<T>;
+    /** Any error emitted by the feature-flag observable. */
     error?: unknown;
     /**
-     * @param enable - Optional provide new enabled state of the feature flag. _Defaults to inversion of current feature flag state_
+     * Toggles the feature flag.
+     *
+     * @param enable - Explicit enabled state. When omitted the current state
+     *   is inverted.
      */
     toggleFeature: (enable?: boolean) => void;
 }
 /**
- * Custom hook that retrieves a feature flag from a feature flag provider.
+ * React hook that retrieves and manages a single feature flag.
+ *
+ * @template T - Value type carried by the feature flag.
+ * @param provider - The feature-flag provider instance.
+ * @param key - Unique key identifying the feature flag.
+ * @returns A {@link UseFeatureResult} with the flag value, toggle helper,
+ *   and any error.
  *
- * @template T - The type of the feature flag value.
- * @param {IFeatureFlagProvider} provider - The feature flag provider.
- * @param {string} key - The key of the feature flag.
- * @returns {UseFeatureResult<T>} - An object containing the feature flag value, a function to toggle the feature flag, and any error that occurred.
+ * @example
+ * ```ts
+ * const { feature, toggleFeature } = useFeature(provider, 'dark-mode');
+ * console.log(feature?.enabled);
+ * ```
  */
 export declare const useFeature: <T = unknown>(provider: IFeatureFlagProvider, key: string) => UseFeatureResult<T>;
 export default useFeature;

package/dist/types/feature-flag/useFeatures.d.ts

@@ -1,21 +1,38 @@
 import type { IFeatureFlagProvider, IFeatureFlag } from '@equinor/fusion-framework-module-feature-flag';
 import type { FeatureSelectorFn } from '@equinor/fusion-framework-module-feature-flag/selectors';
+/**
+ * Return type of the {@link useFeatures} hook.
+ */
 export interface UseFeaturesResult {
+    /** Array of all resolved feature flags. */
     features: IFeatureFlag[];
+    /** Any error emitted by the feature-flag observable. */
     error: unknown;
     /**
+     * Toggles a feature flag by key.
+     *
      * @param key - The key of the feature flag.
-     * @param enable - Optional provide new enabled state of the feature flag. _Defaults to inversion of current feature flag state_
+     * @param enable - Explicit enabled state. When omitted the current state
+     *   is inverted.
      */
     toggleFeature: (key: string, enable?: boolean) => void;
 }
 /**
- * Custom hook that provides access to the feature flags and their values.
+ * React hook that returns all feature flags from a provider, with optional
+ * filtering.
+ *
+ * @param provider - The feature-flag provider instance, or `null`/`undefined`
+ *   when not yet available.
+ * @param selector - Optional predicate to filter the feature flags.
+ * @returns A {@link UseFeaturesResult} with the flags, a toggle helper,
+ *   and any error.
+ * @throws {Error} If `toggleFeature` is called when the provider is missing.
  *
- * @param provider - The feature flag provider.
- * @param selector - Optional function to filter the feature flags.
- * @returns An object containing the features, any error that occurred while retrieving them, and a function to set the enabled state of a feature flag.
- * @throws Error if the feature flag provider is missing.
+ * @example
+ * ```ts
+ * const { features, toggleFeature } = useFeatures(provider);
+ * toggleFeature('beta', true);
+ * ```
  */
 export declare const useFeatures: (provider?: IFeatureFlagProvider | null, selector?: FeatureSelectorFn) => UseFeaturesResult;
 export default useFeatures;

package/dist/types/feature-flag/useFrameworkFeature.d.ts

@@ -1,11 +1,18 @@
 import { useFeature } from './useFeature';
 /**
- * Custom hook that allows accessing a framework feature based on a given feature flag key.
+ * React hook that retrieves a single feature flag from the **framework-level**
+ * feature-flag provider.
  *
- * @template T - The type of the feature.
- * @param {string} key - The feature flag key.
- * @returns {ReturnType<typeof useFeature<T>>} - The result of the feature hook.
- * @throws {Error} - If feature flagging is not enabled in the framework.
+ * @template T - Value type carried by the feature flag.
+ * @param key - Unique key identifying the feature flag.
+ * @returns A {@link UseFeatureResult} with the flag value, toggle helper,
+ *   and any error.
+ * @throws {Error} If the `FeatureFlagModule` is not enabled in the framework.
+ *
+ * @example
+ * ```ts
+ * const { feature, toggleFeature } = useFrameworkFeature('experimental-ui');
+ * ```
  */
 export declare const useFrameworkFeature: <T>(key: string) => ReturnType<typeof useFeature<T>>;
 export default useFrameworkFeature;

package/dist/types/feature-flag/useFrameworkFeatures.d.ts

@@ -1,9 +1,16 @@
 import { useFeatures } from './useFeatures';
 /**
- * Custom hook that provides access to framework-specific feature flags.
- * It returns the result of the `useFeatures` hook from the `featureFlag` module.
- * @returns The result of the `useFeatures` hook.
- * @throws Error if feature flagging is not enabled in the framework.
+ * React hook that returns all feature flags from the **framework-level**
+ * feature-flag provider.
+ *
+ * @returns A {@link UseFeaturesResult} containing all framework feature flags,
+ *   a toggle helper, and any error.
+ * @throws {Error} If the `FeatureFlagModule` is not enabled in the framework.
+ *
+ * @example
+ * ```ts
+ * const { features, toggleFeature } = useFrameworkFeatures();
+ * ```
  */
 export declare const useFrameworkFeatures: () => ReturnType<typeof useFeatures>;
 export default useFrameworkFeatures;

package/dist/types/hooks/index.d.ts

@@ -1,2 +1,10 @@
+/**
+ * Convenience hooks for common framework operations.
+ *
+ * @remarks
+ * Available via the `@equinor/fusion-framework-react/hooks` sub-entry-point.
+ *
+ * @module
+ */
 export { useCurrentUser } from './use-current-user';
 export { useHttpClient } from './use-http-client';

package/dist/types/hooks/use-current-user.d.ts

@@ -1,2 +1,16 @@
 import type { AccountInfo } from '@equinor/fusion-framework-module-msal';
+/**
+ * React hook that returns the currently authenticated user's account info.
+ *
+ * @returns The {@link AccountInfo} of the signed-in user, or `undefined` if
+ *   no user is authenticated.
+ *
+ * @example
+ * ```tsx
+ * const UserGreeting = () => {
+ *   const user = useCurrentUser();
+ *   return <span>Hello, {user?.name ?? 'Guest'}</span>;
+ * };
+ * ```
+ */
 export declare const useCurrentUser: () => AccountInfo | undefined;

package/dist/types/hooks/use-http-client.d.ts

@@ -1,5 +1,20 @@
 import type { Fusion } from '@equinor/fusion-framework';
+/** Resolved HTTP client instance returned by the framework HTTP module. */
 type HttpClient = ReturnType<Fusion['modules']['http']['createClient']>;
+/** Well-known HTTP client keys pre-configured by the framework. */
 type FrameworkHttpClient = 'portal' | 'people';
+/**
+ * React hook that returns a pre-configured HTTP client from the framework.
+ *
+ * @param name - Key of the HTTP client to retrieve (e.g. `'portal'` or `'people'`).
+ * @returns The resolved {@link HttpClient} instance.
+ * @throws {Error} If no client is configured for the given key.
+ *
+ * @example
+ * ```ts
+ * const client = useHttpClient('portal');
+ * client.fetch('/api/data').subscribe(console.log);
+ * ```
+ */
 export declare const useHttpClient: (name: FrameworkHttpClient) => HttpClient;
 export {};

package/dist/types/http/index.d.ts

@@ -1,2 +1,12 @@
+/**
+ * HTTP sub-entry-point (`@equinor/fusion-framework-react/http`).
+ *
+ * @remarks
+ * Re-exports the framework-level {@link useHttpClient} hook as
+ * `useFrameworkHttpClient` together with all exports from the
+ * standalone HTTP React module.
+ *
+ * @module
+ */
 export { useHttpClient as useFrameworkHttpClient } from '../hooks/use-http-client';
 export * from '@equinor/fusion-framework-react-module-http';

package/dist/types/index.d.ts

@@ -1,4 +1,12 @@
 /**
+ * React bindings for the Fusion Framework.
+ *
+ * @remarks
+ * This package provides React components, context providers, and hooks for
+ * initialising and consuming a Fusion Framework instance inside a React
+ * application tree. It is the main entry-point for portals and host
+ * applications that need to bootstrap the framework with React.
+ *
  * [[include:framework-react/README.MD]]
  * @module
  */

package/dist/types/useFramework.d.ts

@@ -1,12 +1,24 @@
 import type { Fusion } from '@equinor/fusion-framework';
 import type { AnyModule } from '@equinor/fusion-framework-module';
 /**
+ * React hook that returns the current Fusion Framework instance from context.
+ *
+ * @remarks
+ * The hook first looks for a framework instance provided via
+ * {@link FrameworkProvider}. If none is found it falls back to the global
+ * `window.Fusion` object. A console warning / error is emitted when the
+ * framework cannot be resolved.
+ *
+ * @template TModules - Tuple of additional module types expected on the
+ *   framework instance (used for type-narrowing only).
+ * @returns The active {@link Fusion} instance.
+ *
  * @example
  * ```ts
- * const useSometing = () => {
- *  const fusion = useFramework();
- *  return fusion.something;
- * }
+ * const useMyService = () => {
+ *   const fusion = useFramework();
+ *   return fusion.modules.http.createClient('my-service');
+ * };
  * ```
  */
 export declare const useFramework: <TModules extends Array<AnyModule> = []>() => Fusion<TModules>;

package/dist/types/useFrameworkModule.d.ts

@@ -1,12 +1,19 @@
 import type { FusionModules, FusionModulesInstance } from '@equinor/fusion-framework';
 import type { AnyModule, ModuleKey, ModuleType, ModuleTypes } from '@equinor/fusion-framework-module';
 /**
- * Retrieves a module from the framework instance based on its name.
+ * React hook that retrieves a module from the Fusion Framework by name.
  *
- * @template TType - The type of the module to retrieve.
- * @template TKey - The type of the module name.
- * @param name - The name of the module to retrieve.
- * @returns The requested module from the framework instance.
- * @throws Error if the requested module is not included in the framework instance.
+ * @template TType - The expected module type (used for type-narrowing).
+ * @template TKey - The module key string.
+ * @param name - The registered name of the module to retrieve.
+ * @returns The resolved module instance, or `undefined` if the module is
+ *   not registered.
+ *
+ * @example
+ * ```ts
+ * import type { HttpModule } from '@equinor/fusion-framework-module-http';
+ *
+ * const http = useFrameworkModule<HttpModule>('http');
+ * ```
  */
 export declare const useFrameworkModule: <TType extends AnyModule | unknown = unknown, TKey extends string = ModuleKey<ModuleTypes<FusionModules<[TType]>>>>(name: TKey) => TType extends AnyModule ? ModuleType<TType> | undefined : FusionModulesInstance[Extract<keyof FusionModulesInstance, TKey>] | undefined;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "8.0.0-next.0";
+export declare const version = "8.0.0";