@equinor/fusion-framework-module-bookmark 4.0.1 → 4.0.3

package/dist/types/BookmarkClient.d.ts

@@ -25,6 +25,7 @@ export declare class BookmarkClient implements IBookmarkClient {
      * Constructs a new `BookmarkClient` instance with the provided `BookmarksApiClient`.
      *
      * @param api - The `BookmarksApiClient` instance to use for making API requests.
+     * @param options - Optional client options, such as the cache expiry time.
      */
     constructor(api: BookmarksApiClient<'json$'>, options?: {
         expire?: number;

package/dist/types/{BookmarkProvider.error.d.ts → BookmarkFlowError.d.ts}

@@ -1,5 +1,5 @@
 import type { ActionWithSuffix } from '@equinor/fusion-observable';
-import type { BookmarkActions } from './BookmarkProvider.actions';
+import type { BookmarkActions } from './bookmark-actions';
 /**
  * Error thrown inside bookmark store flows (side-effect pipelines) when an
  * API call or observable chain fails.
@@ -10,6 +10,13 @@ import type { BookmarkActions } from './BookmarkProvider.actions';
 export declare class BookmarkFlowError extends Error {
     /** The request action that triggered the failed flow. */
     readonly action: ActionWithSuffix<BookmarkActions, 'request'>;
+    /**
+     * Constructs a new `BookmarkFlowError`.
+     *
+     * @param message - Human-readable error message.
+     * @param action - The request action that triggered the failed flow.
+     * @param options - Optional `ErrorOptions` (e.g. `cause`).
+     */
     constructor(message: string, 
     /** The request action that triggered the failed flow. */
     action: ActionWithSuffix<BookmarkActions, 'request'>, options?: ErrorOptions);
@@ -21,6 +28,4 @@ export declare class BookmarkFlowError extends Error {
  * Distinct from {@link BookmarkFlowError}, which is scoped to internal
  * store flow pipelines.
  */
-export declare class BookmarkProviderError extends Error {
-    constructor(message: string, options?: ErrorOptions);
-}
+export { BookmarkProviderError } from './BookmarkProviderError';

package/dist/types/{BookmarkConfigurator.d.ts → BookmarkModuleConfigurator.d.ts}

@@ -1,5 +1,4 @@
-import { BaseConfigBuilder, type ConfigBuilderCallback, type ConfigBuilderCallbackArgs, type ModulesInstanceType } from '@equinor/fusion-framework-module';
-import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
+import { BaseConfigBuilder, type ConfigBuilderCallback, type ModulesInstanceType } from '@equinor/fusion-framework-module';
 import type { ILogger, LogLevel } from '@equinor/fusion-log';
 import type { BookmarkModule } from './bookmark-module';
 import type { BookmarkModuleConfig } from './types';
@@ -17,6 +16,13 @@ import type { BookmarkModuleConfig } from './types';
 export declare class BookmarkModuleConfigurator extends BaseConfigBuilder<BookmarkModuleConfig> {
     #private;
     defaultExpireTime: number;
+    /**
+     * Constructs a new `BookmarkModuleConfigurator`.
+     *
+     * @param options - Optional configurator options.
+     * @param options.log - Logger instance inherited from the parent module, if any.
+     * @param options.ref - Reference to sibling module instances available during configuration.
+     */
     constructor(options?: {
         log?: ILogger;
         ref?: ModulesInstanceType<[BookmarkModule]>;
@@ -93,6 +99,7 @@ export declare class BookmarkModuleConfigurator extends BaseConfigBuilder<Bookma
     setApplicationResolver(cb: ConfigBuilderCallback<BookmarkModuleConfig['resolve']['application']>): void;
     /**
      * Sets a filter for the bookmark module.
+     * @template TKey - The filter key being set.
      * @param key - The key of the filter to set.
      * @param value - The value to set for the filter.
      *
@@ -101,7 +108,5 @@ export declare class BookmarkModuleConfigurator extends BaseConfigBuilder<Bookma
      * - context: Only return bookmarks for the resolved context.
      */
     setFilter<TKey extends keyof BookmarkModuleConfig['filters']>(key: TKey, value: BookmarkModuleConfig['filters'][TKey]): void;
-    protected _resolveAppProvider(init: ConfigBuilderCallbackArgs): Promise<AppModuleProvider | undefined>;
-    protected _processConfig(config: Partial<BookmarkModuleConfig>, _init: ConfigBuilderCallbackArgs): Promise<BookmarkModuleConfig>;
 }
 export default BookmarkModuleConfigurator;

package/dist/types/BookmarkProvider.d.ts

@@ -3,9 +3,9 @@ import { type FrameworkEventInitType } from '@equinor/fusion-framework-module-ev
 import { SemanticVersion } from '@equinor/fusion-framework-module';
 import type { Bookmark, BookmarkData, BookmarkWithoutData, Bookmarks, BookmarkModuleConfig } from './types';
 import type { BookmarkUpdate, IBookmarkClient } from './BookmarkClient.interface';
-import { type BookmarkActions } from './BookmarkProvider.actions';
-import { type BookmarkState } from './BookmarkProvider.store';
-import { type BookmarkFlowError } from './BookmarkProvider.error';
+import { type BookmarkActions } from './bookmark-actions';
+import { type BookmarkState } from './create-bookmark-store';
+import { type BookmarkFlowError } from './BookmarkFlowError';
 import type { BookmarkProviderEventMap } from './BookmarkProvider.events';
 import type { BookmarkCreateArgs, BookmarkPayloadGenerator, BookmarkUpdateOptions, IBookmarkProvider } from './BookmarkProvider.interface';
 /**
@@ -28,93 +28,117 @@ export declare class BookmarkProvider implements IBookmarkProvider {
     /**
      * @deprecated
      * this will be removed as soon as applications have been migrated to use the bookmark provider
+     * @param fn - The payload generator callback to register.
+     * @template T - The bookmark data type produced by the generator.
+     * @returns A function that unregisters the payload generator when called.
      */
     addStateCreator<T extends BookmarkData>(fn: BookmarkPayloadGenerator<T>): VoidFunction;
     /**
      * @deprecated
      * this will be removed as soon as applications have been migrated to use the bookmark provider
+     * @param id - The ID of the bookmark to delete.
      */
     deleteBookmarkByIdAsync(id: string): Promise<void>;
     /**
      * @deprecated
      * this will be removed as soon as applications have been migrated to use the bookmark provider
+     * @param id - The ID of the bookmark to add as a favorite.
+     * @returns The updated bookmark, or undefined if it could not be found.
      */
     addBookmarkFavoriteAsync(id: string): Promise<Bookmark | undefined>;
     /**
      * @deprecated
      * this will be removed as soon as applications have been migrated to use the bookmark provider
+     * @param id - The ID of the bookmark to remove as a favorite.
      */
     removeBookmarkFavoriteAsync(id: string): Promise<void>;
     /**
      * @deprecated
      * this will be removed as soon as applications have been migrated to use the bookmark provider
+     * @param id - The ID of the bookmark to get.
+     * @returns The bookmark, or null if it could not be found.
      */
     getBookmarkById(id: string): Promise<Bookmark | null>;
     /**
      * Gets the semantic version of the bookmark provider.
+     * @returns The semantic version of the bookmark provider.
      */
     get version(): SemanticVersion;
+    /** @returns The configured bookmark filters. */
     get filters(): BookmarkModuleConfig['filters'];
     /**
      * Gets the `IBookmarkClient` instance used by this `BookmarkProvider`.
+     * @returns The `IBookmarkClient` instance.
      */
     get client(): IBookmarkClient;
     /**
      * Gets the currently active bookmark (if any).
+     * @returns An observable of the currently active bookmark.
      */
     get currentBookmark$(): Observable<Bookmark | null | undefined>;
     /**
      * Gets an observable that emits the current list of bookmarks.
+     * @returns An observable of the current list of bookmarks.
      */
     get bookmarks$(): Observable<Array<BookmarkWithoutData>>;
     /**
      * Gets the current list of bookmarks.
+     * @returns The current list of bookmarks.
      */
     get bookmarks(): Array<BookmarkWithoutData>;
     /**
      * Gets the currently active bookmark.
+     * @returns The currently active bookmark, or null/undefined if there is none.
      */
     get currentBookmark(): Bookmark | null | undefined;
     /**
      * Represents an observable stream of the bookmark status.
+     * @returns An observable of the bookmark status.
      */
     get status$(): Observable<BookmarkState['status']>;
     /**
      * Gets an observable that emits the current list of bookmark errors.
+     * @returns An observable of the current list of bookmark errors.
      */
     get errors$(): Observable<Array<BookmarkFlowError>>;
     /**
      * Determines whether there are any bookmark creators configured.
-     * `true` if there are any bookmark creators configured, `false` otherwise.
+     * @returns `true` if there are any bookmark creators configured, `false` otherwise.
      */
     get canCreateBookmarks(): boolean;
     /**
      * Gets the source system value from the configuration.
+     * @returns The source system value.
      */
     get sourceSystem(): BookmarkModuleConfig['sourceSystem'];
     /**
      * Gets the resolved application from the bookmark module configuration.
+     * @returns The resolved application resolver.
      */
     get resolvedApplication(): BookmarkModuleConfig['resolve']['application'];
     /**
      * Gets the resolved context from the bookmark module configuration.
+     * @returns The resolved context resolver.
      */
     get resolvedContext(): BookmarkModuleConfig['resolve']['context'];
-    protected get _apiClient(): IBookmarkClient;
     /**
      * configured logger instance.
+     * @returns The configured logger.
      */
     protected get _log(): BookmarkModuleConfig['log'];
     /**
      * configured resolvers
+     * @returns The configured resolvers.
      */
     protected get _resolve(): BookmarkModuleConfig['resolve'];
     /**
      * configured event provider.
+     * @returns The configured event provider.
      */
     protected get _event(): BookmarkModuleConfig['eventProvider'];
     /**
      * configured parent bookmark provider
+     * @returns The configured parent bookmark provider.
      */
     protected get _parent(): BookmarkModuleConfig['parent'];
     /**
@@ -126,6 +150,7 @@ export declare class BookmarkProvider implements IBookmarkProvider {
     /**
      * Registers an event listener for the specified event on the BookmarkProvider.
      *
+     * @template TType - The key of the `BookmarkProviderEventMap` identifying the event.
      * @param eventName - The name of the event to listen for. Must be a key of the `BookmarkProviderEventMap` type.
      * @param callback - The callback function to be invoked when the event is triggered.
      *      The callback will receive the event object as its parameter, which will be of the type corresponding to the `eventName`.
@@ -136,6 +161,7 @@ export declare class BookmarkProvider implements IBookmarkProvider {
      * Adds a new payload generator function to the BookmarkProvider.
      * The payload generator function will be used to generate the payload for a bookmark-related action.
      *
+     * @template T - The type of the bookmark data the payload generator produces.
      * @param fn - The payload generator function to add. It should be of type `PayloadGenerator<T>`, where `T` is the type of the bookmark data.
      * @returns A function that can be called to remove the added payload generator.
      */
@@ -169,6 +195,7 @@ export declare class BookmarkProvider implements IBookmarkProvider {
      * @param bookmarkId The unique identifier of the bookmark.
      * @param options An optional object that allows excluding the bookmark payload from the result.
      * @returns An observable that emits the combined result of fetching the bookmark and bookmark data.
+     * @throws The error encountered while fetching the bookmark or its data, after logging it.
      */
     getBookmark<T extends BookmarkData = BookmarkData>(bookmarkId: string, options?: {
         excludePayload?: boolean;
@@ -176,6 +203,7 @@ export declare class BookmarkProvider implements IBookmarkProvider {
     /**
      * Retrieves a bookmark asynchronously.
      *
+     * @template T - The type of the bookmark payload.
      * @param id - The ID of the bookmark to retrieve.
      * @param options - Optional parameters for the retrieval.
      * @param options.excludePayload - Specifies whether to exclude the payload from the bookmark.
@@ -234,17 +262,15 @@ export declare class BookmarkProvider implements IBookmarkProvider {
      * @param bookmark_or_id - The bookmark or ID to set as the current bookmark.
      * @returns An observable that emits the next bookmark or null.
      * @template T - The type of the bookmark data.
+     * @throws {BookmarkProviderError} If the onCurrentBookmarkChange event is canceled by a listener, or resolving the bookmark fails.
      */
     setCurrentBookmark<T extends BookmarkData = BookmarkData>(bookmark_or_id: Bookmark<T> | string | null): Observable<Bookmark<T> | null>;
     /**
-     * Sets the current bookmark.
-     * This method dispatches an event to notify listeners of a change in the current bookmark,
-     * and then dispatches a request to set the active bookmark in the application state.
+     * Sets the current bookmark asynchronously.
      *
-     * The request will be canceled if the subscription is unsubscribed before the request completes.
-     *
-     * @param bookmarkId - The ID of the bookmark to set as the current bookmark.
-     * @returns A subscription to the operation that sets the current bookmark.
+     * @template T - The type of the bookmark data.
+     * @param bookmark_or_id - The bookmark or ID to set as the current bookmark.
+     * @returns A promise that resolves to the next bookmark or null.
      */
     setCurrentBookmarkAsync<T extends BookmarkData = BookmarkData>(bookmark_or_id: Bookmark<T> | string | null): Promise<Bookmark<T> | null>;
     /**
@@ -253,12 +279,14 @@ export declare class BookmarkProvider implements IBookmarkProvider {
      * @template T - The type of bookmark data.
      * @param {BookmarkCreateArgs<T>} newBookmarkData - The data for creating the bookmark.
      * @returns {Observable<Bookmark<T>>} - An observable that emits the created bookmark.
+     * @throws {BookmarkProviderError} If resolving the bookmark data fails, the onBookmarkCreate event is canceled, the create request fails, or the request times out.
      */
     createBookmark<T extends BookmarkData = BookmarkData>(newBookmarkData: BookmarkCreateArgs<T>): Observable<Bookmark<T>>;
     /**
      * Asynchronously creates a new bookmark.
      *
-     * @param bookmark - The new bookmark to create.
+     * @template T - The type of bookmark data.
+     * @param args - The data for creating the bookmark.
      * @returns A promise that resolves to the created bookmark with its associated data.
      */
     createBookmarkAsync<T extends BookmarkData = BookmarkData>(args: BookmarkCreateArgs<T>): Promise<Bookmark<T>>;
@@ -271,14 +299,18 @@ export declare class BookmarkProvider implements IBookmarkProvider {
      * @param {BookmarkUpdate<T>} [bookmarkUpdates] - The updates to apply to the bookmark.
      * @param {BookmarkUpdateOptions} [options] - The options for updating the bookmark.
      * @returns {Observable<Bookmark<T>>} - An observable that emits the updated bookmark.
+     * @throws {BookmarkProviderError} If bookmarkUpdates is omitted while excludePayloadGeneration is set, generating the payload fails, the onBookmarkUpdate event is canceled, the update request fails, or the request times out.
      */
     updateBookmark<T extends BookmarkData = BookmarkData>(bookmarkId: string, bookmarkUpdates?: BookmarkUpdate<T>, options?: BookmarkUpdateOptions): Observable<Bookmark<T>>;
     /**
      * Updates a bookmark asynchronously.
      *
-     * @todo - remove the deprecated method in the next major version
+     * @todo TODO(#5140) - remove the deprecated overload accepting a full bookmark in the next major version
      *
-     * @param bookmark - The bookmark to update.
+     * @template T - The type of the bookmark data.
+     * @param id_or_bookmark - The ID of the bookmark to update, or (deprecated) the full bookmark object.
+     * @param updates_or_options - The updates to apply, or (deprecated) the update options when using the bookmark overload.
+     * @param options - The options for updating the bookmark.
      * @returns A promise that resolves to the updated bookmark with its associated data.
      */
     updateBookmarkAsync<T extends BookmarkData = BookmarkData>(id_or_bookmark: string | Bookmark<T>, updates_or_options?: BookmarkUpdate<T> | BookmarkUpdateOptions, options?: BookmarkUpdateOptions): Promise<Bookmark<T>>;
@@ -299,10 +331,11 @@ export declare class BookmarkProvider implements IBookmarkProvider {
      */
     deleteBookmarkAsync(bookmarkId: string): Promise<void>;
     /**
-     * Adds a bookmark to the favorites.
+     * Adds a bookmark to favorites.
      *
      * @param bookmarkId - The ID of the bookmark to add.
-     * @returns A Promise that resolves to the added bookmark, or null if the bookmark was not added.
+     * @returns An observable that emits the added bookmark, or undefined if it could not be resolved.
+     * @throws {BookmarkProviderError} If the onBookmarkFavouriteAdd event is canceled, the add request fails, or the request times out.
      */
     addBookmarkToFavorites(bookmarkId: string): Observable<BookmarkWithoutData | undefined>;
     /**
@@ -330,7 +363,8 @@ export declare class BookmarkProvider implements IBookmarkProvider {
     /**
      * Checks if a bookmark is in the favorites.
      * @param bookmarkId - The ID of the bookmark to check.
-     * @returns A promise that resolves to a boolean indicating whether the bookmark is in the favorites.
+     * @returns An observable that emits a boolean indicating whether the bookmark is in the favorites.
+     * @throws {BookmarkProviderError} If checking the favorite status fails.
      */
     isBookmarkInFavorites(bookmarkId: string): Observable<boolean>;
     /**
@@ -340,20 +374,46 @@ export declare class BookmarkProvider implements IBookmarkProvider {
      * @returns A Promise that resolves to a boolean indicating whether the bookmark is in the user's favorites.
      */
     isBookmarkInFavoritesAsync(bookmarkId: string): Promise<boolean>;
+    /**
+     * Fetches a single bookmark's metadata (without payload) via the store.
+     *
+     * @param bookmarkId - The unique identifier of the bookmark to fetch.
+     * @param options - Optional settings, including a custom `timeout` in milliseconds.
+     * @returns An observable that emits the bookmark's metadata once fetched.
+     * @throws {BookmarkProviderError} If the fetch fails or times out.
+     */
     protected _getBookmarkInfo(bookmarkId: string, options?: {
         timeout?: number;
     }): Observable<BookmarkWithoutData>;
+    /**
+     * Fetches a single bookmark's payload data via the store.
+     *
+     * @template T - The type of the bookmark payload.
+     * @param bookmarkId - The unique identifier of the bookmark whose data to fetch.
+     * @param options - Optional settings, including a custom `timeout` in milliseconds.
+     * @returns An observable that emits the bookmark's payload data once fetched.
+     * @throws {BookmarkProviderError} If the fetch fails or times out.
+     */
     protected _getBookmarkData<T extends BookmarkData = BookmarkData>(bookmarkId: string, options?: {
         timeout?: number;
     }): Observable<T | null>;
     /**
      * Dispatches an event of the specified type with the provided arguments.
      *
+     * @template TType - The specific event type key being dispatched.
      * @param type - The type of the event to dispatch.
      * @param args - The arguments to pass to the event.
      * @returns A promise that resolves with the result of the event dispatch.
      */
     protected _dispatchEvent<TType extends keyof BookmarkProviderEventMap>(type: TType, args: FrameworkEventInitType<BookmarkProviderEventMap[NoInfer<TType>]>): Promise<BookmarkProviderEventMap[NoInfer<TType>]>;
+    /**
+     * Creates a scoped action reference and a filtered action stream containing only
+     * actions tagged with that reference (or the provided `ref`, if given).
+     *
+     * @template TAction - The specific action type emitted on the scoped stream.
+     * @param ref - An existing reference to scope actions to; a new GUID is generated when omitted.
+     * @returns An object containing the resolved `ref` and the `action$` stream filtered to it.
+     */
     protected _useScopedActions<TAction extends BookmarkActions>(ref?: string): {
         ref: string;
         action$: Observable<TAction>;
@@ -362,5 +422,8 @@ export declare class BookmarkProvider implements IBookmarkProvider {
      * Disposes the BookmarkProvider.
      */
     dispose(): void;
+    /**
+     * Disposes the BookmarkProvider via the `Symbol.dispose` protocol.
+     */
     [Symbol.dispose](): void;
 }

package/dist/types/BookmarkProvider.interface.d.ts

@@ -2,7 +2,7 @@ import type { Observable, ObservableInput } from 'rxjs';
 import type { Bookmark, BookmarkData, BookmarkWithoutData } from './types';
 import type { BookmarkNew, BookmarkUpdate } from './BookmarkClient.interface';
 import type { BookmarkProviderEventMap } from './BookmarkProvider.events';
-import type { BookmarkState } from './BookmarkProvider.store';
+import type { BookmarkState } from './create-bookmark-store';
 /**
  * Arguments for creating a bookmark via {@link IBookmarkProvider.createBookmark}.
  *

package/dist/types/BookmarkProvider.selectors.d.ts

@@ -1,5 +1,5 @@
-import type { BookmarkFlowError } from './BookmarkProvider.error';
-import type { BookmarkState } from './BookmarkProvider.store';
+import type { BookmarkFlowError } from './BookmarkFlowError';
+import type { BookmarkState } from './create-bookmark-store';
 import type { Bookmark, BookmarkData } from './types';
 /**
  * Selects all bookmarks from the store state as an array.
@@ -31,7 +31,7 @@ export declare const activeBookmarkSelector: <T extends BookmarkData>(state: Boo
  * @param state - The bookmark state.
  * @returns The status from the bookmark state.
  */
-export declare const statusSelector: (state: BookmarkState) => BookmarkState["status"];
+export declare const statusSelector: (state: BookmarkState) => BookmarkState['status'];
 /**
  * Selects and returns an array of bookmark flow errors from the state.
  *

package/dist/types/BookmarkProviderError.d.ts

@@ -0,0 +1,16 @@
+/**
+ * General-purpose error thrown by {@link BookmarkProvider} methods when a
+ * high-level operation (create, update, delete, set current, etc.) fails.
+ *
+ * Distinct from {@link BookmarkFlowError}, which is scoped to internal
+ * store flow pipelines.
+ */
+export declare class BookmarkProviderError extends Error {
+    /**
+     * Constructs a new `BookmarkProviderError`.
+     *
+     * @param message - Human-readable error message.
+     * @param options - Optional `ErrorOptions` (e.g. `cause`).
+     */
+    constructor(message: string, options?: ErrorOptions);
+}

package/dist/types/{BookmarkProvider.actions.d.ts → bookmark-actions.d.ts}

@@ -1,7 +1,7 @@
 import { type Action, type ActionTypes } from '@equinor/fusion-observable';
 import type { Bookmark, BookmarkData, BookmarkWithoutData, Bookmarks } from './types';
 import type { BookmarkNew, BookmarkUpdate, BookmarksFilter } from './BookmarkClient.interface';
-import type { BookmarkFlowError } from './BookmarkProvider.error';
+import type { BookmarkFlowError } from './BookmarkFlowError';
 /**
  * Represents the metadata associated with a bookmark action.
  */
@@ -58,10 +58,10 @@ export declare const bookmarkActions: {
         ref: string;
     }> & {
         success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[payload: {
-            type: "delete_bookmark" | "remove_favourite_bookmark";
+            type: 'delete_bookmark' | 'remove_favourite_bookmark';
             bookmarkId: string;
         }, meta: BookmarkActionMeta], {
-            type: "delete_bookmark" | "remove_favourite_bookmark";
+            type: 'delete_bookmark' | 'remove_favourite_bookmark';
             bookmarkId: string;
         }, "remove_bookmark::success", never, BookmarkActionMeta>;
         failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[payload: BookmarkFlowError, meta: BookmarkActionMeta], BookmarkFlowError, "remove_bookmark::failure", never, BookmarkActionMeta>;

package/dist/types/bookmark-flows/bookmark-api-flows.d.ts

@@ -0,0 +1,11 @@
+import type { Flow } from '@equinor/fusion-observable';
+import type { BookmarkActions } from '../bookmark-actions';
+import type { BookmarkState } from '../create-bookmark-store';
+import type { IBookmarkClient } from '../BookmarkClient.interface';
+/**
+ * Defines a set of flows that handle various bookmark-related actions, such as fetching, creating, updating, and deleting bookmarks.
+ *
+ * @param api - An instance of `IBookmarkClient` that provides the necessary API methods for interacting with the bookmark service.
+ * @returns A combined flow that handles all the bookmark-related actions.
+ */
+export declare const bookmarkApiFlows: (api: IBookmarkClient) => Flow<BookmarkActions, BookmarkState>;

package/dist/types/bookmark-flows/handle-add-bookmark-as-favorite.d.ts

@@ -0,0 +1,10 @@
+import type { Flow } from '@equinor/fusion-observable';
+import { type BookmarkActions } from '../bookmark-actions';
+import type { IBookmarkClient } from '../BookmarkClient.interface';
+/**
+ * Handles the flow of adding a bookmark as a favorite.
+ *
+ * @param api - The `IBookmarkClient` API instance to use for interacting with bookmarks.
+ * @returns An RxJS `Flow` that handles the `addBookmarkAsFavourite` action.
+ */
+export declare const handleAddBookmarkAsFavorite: (api: IBookmarkClient) => Flow<BookmarkActions>;

package/dist/types/bookmark-flows/handle-create-bookmark.d.ts

@@ -0,0 +1,10 @@
+import type { Flow } from '@equinor/fusion-observable';
+import { type BookmarkActions } from '../bookmark-actions';
+import type { IBookmarkClient } from '../BookmarkClient.interface';
+/**
+ * Creates a Flow for handling creating bookmarks.
+ *
+ * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for creating bookmarks.
+ * @returns A flow that listens for `createBookmark` actions, creates a new bookmark using the provided API.
+ */
+export declare const handleCreateBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;

package/dist/types/bookmark-flows/handle-delete-bookmark.d.ts

@@ -0,0 +1,10 @@
+import type { Flow } from '@equinor/fusion-observable';
+import { type BookmarkActions } from '../bookmark-actions';
+import type { IBookmarkClient } from '../BookmarkClient.interface';
+/**
+ * Creates a flow for handling deleting bookmarks.
+ *
+ * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for deleting bookmarks.
+ * @returns A flow that listens for `deleteBookmark` actions, deletes the bookmark using the provided API.
+ */
+export declare const handleDeleteBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;

package/dist/types/bookmark-flows/handle-fetch-all-bookmark.d.ts

@@ -0,0 +1,10 @@
+import type { Flow } from '@equinor/fusion-observable';
+import { type BookmarkActions } from '../bookmark-actions';
+import type { IBookmarkClient } from '../BookmarkClient.interface';
+/**
+ * Creates a Flow for handling fetching users bookmarks.
+ *
+ * @param api - The bookmark API client to use for fetching bookmarks.
+ * @returns An observable that emits the result of the bookmark fetch operation.
+ */
+export declare const handleFetchAllBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;

package/dist/types/bookmark-flows/handle-fetch-bookmark-data.d.ts

@@ -0,0 +1,10 @@
+import type { Flow } from '@equinor/fusion-observable';
+import { type BookmarkActions } from '../bookmark-actions';
+import type { IBookmarkClient } from '../BookmarkClient.interface';
+/**
+ * Creates a flow for handling fetching bookmark data.
+ *
+ * @param api - The bookmark client API.
+ * @returns A flow of bookmark actions.
+ */
+export declare const handleFetchBookmarkData: (api: IBookmarkClient) => Flow<BookmarkActions>;

package/dist/types/bookmark-flows/handle-fetch-bookmark.d.ts

@@ -0,0 +1,10 @@
+import type { Flow } from '@equinor/fusion-observable';
+import { type BookmarkActions } from '../bookmark-actions';
+import type { IBookmarkClient } from '../BookmarkClient.interface';
+/**
+ * Handles the fetch bookmark action by making an API request to get the bookmark by its ID.
+ *
+ * @param api - The bookmark client API.
+ * @returns A flow that handles the fetch bookmark action.
+ */
+export declare const handleFetchBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;

package/dist/types/bookmark-flows/handle-remove-bookmark-from-favorites.d.ts

@@ -0,0 +1,10 @@
+import type { Flow } from '@equinor/fusion-observable';
+import { type BookmarkActions } from '../bookmark-actions';
+import type { IBookmarkClient } from '../BookmarkClient.interface';
+/**
+ * Creates a Flow for handling removing a bookmark from favorites.
+ *
+ * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for managing favorite bookmarks.
+ * @returns A flow that listens for `removeBookmarkAsFavorite` actions, removes the bookmark from the user's favorites using the provided API.
+ */
+export declare const handleRemoveBookmarkFromFavorites: (api: IBookmarkClient) => Flow<BookmarkActions>;

package/dist/types/bookmark-flows/handle-remove-bookmark.d.ts

@@ -0,0 +1,14 @@
+import { type Flow } from '@equinor/fusion-observable';
+import { type BookmarkActions } from '../bookmark-actions';
+import type { IBookmarkClient } from '../BookmarkClient.interface';
+/**
+ * Creates a flow for handling bookmark removal.
+ *
+ * This function observes actions related to deleting a bookmark or removing a bookmark as a favorite, and dispatches the appropriate actions for each case.
+ * If the bookmark is currently a favorite, it will dispatch an action to remove it as a favorite.
+ * If the bookmark is not a favorite, it will dispatch an action to delete it.
+ *
+ * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods checking if bookmarks are favorites.
+ * @returns A flow that handles the removal of a bookmark.
+ */
+export declare const handleRemoveBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;

package/dist/types/bookmark-flows/handle-update-bookmark.d.ts

@@ -0,0 +1,10 @@
+import type { Flow } from '@equinor/fusion-observable';
+import { type BookmarkActions } from '../bookmark-actions';
+import type { IBookmarkClient } from '../BookmarkClient.interface';
+/**
+ * Creates a Flow for handling updating bookmarks.
+ *
+ * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for updating bookmarks.
+ * @returns A flow that listens for `updateBookmark` actions, updates the bookmark using the provided API.
+ */
+export declare const handleUpdateBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;

package/dist/types/bookmark-flows/index.d.ts

@@ -0,0 +1,10 @@
+export { handleFetchBookmark } from './handle-fetch-bookmark';
+export { handleFetchBookmarkData } from './handle-fetch-bookmark-data';
+export { handleFetchAllBookmark } from './handle-fetch-all-bookmark';
+export { handleCreateBookmark } from './handle-create-bookmark';
+export { handleUpdateBookmark } from './handle-update-bookmark';
+export { handleDeleteBookmark } from './handle-delete-bookmark';
+export { handleRemoveBookmark } from './handle-remove-bookmark';
+export { handleRemoveBookmarkFromFavorites } from './handle-remove-bookmark-from-favorites';
+export { handleAddBookmarkAsFavorite } from './handle-add-bookmark-as-favorite';
+export { bookmarkApiFlows } from './bookmark-api-flows';

package/dist/types/bookmark-module.d.ts

@@ -3,7 +3,7 @@ import type { EventModule } from '@equinor/fusion-framework-module-event';
 import type { ServicesModule } from '@equinor/fusion-framework-module-services';
 import type { AppModule } from '@equinor/fusion-framework-module-app';
 import type { ContextModule } from '@equinor/fusion-framework-module-context';
-import { BookmarkModuleConfigurator } from './BookmarkConfigurator';
+import { BookmarkModuleConfigurator } from './BookmarkModuleConfigurator';
 import type { IBookmarkProvider } from './BookmarkProvider.interface';
 /** String literal key used to register the bookmark module in the framework. */
 export type BookmarkModuleKey = 'bookmark';