@equinor/fusion-framework-module-bookmark 1.2.13 → 2.0.0

package/dist/types/BookmarkProvider.d.ts

@@ -0,0 +1,462 @@
+import { Observable } from 'rxjs';
+import { Draft } from 'immer';
+import { FrameworkEventInitType } from '@equinor/fusion-framework-module-event';
+import { SemanticVersion } from '@equinor/fusion-framework-module';
+import type { Bookmark, BookmarkData, BookmarkWithoutData, Bookmarks, BookmarkModuleConfig } from './types';
+import { BookmarkNew, BookmarkUpdate, type IBookmarkClient } from './BookmarkClient.interface';
+import { BookmarkActions } from './BookmarkProvider.actions';
+import { BookmarkState } from './BookmarkProvider.store';
+import { BookmarkFlowError } from './BookmarkProvider.error';
+import { BookmarkProviderEventMap } from './BookmarkProvider.events';
+export type BookmarkPayloadGenerator<TData extends BookmarkData = any> = (payload?: Draft<Partial<TData>> | null, initial?: Partial<TData> | null) => Promise<Partial<TData> | void> | Partial<TData> | void;
+export type BookmarkUpdateOptions = {
+    excludePayloadGeneration?: boolean;
+};
+export type BookmarkCreateArgs<T extends BookmarkData> = Omit<BookmarkNew<T>, 'appKey' | 'contextId' | 'sourceSystem'> & Partial<Pick<BookmarkNew<T>, 'appKey'>>;
+/**
+ * The `BookmarkProvider` class is responsible for managing bookmarks in the application.
+ * It provides methods for creating, updating, and removing bookmarks, as well as managing the current bookmark and the list of bookmarks.
+ *
+ * The `BookmarkProvider` uses a `BookmarkStore` to manage the state of the bookmarks, and an `IBookmarkClient` to interact with the backend API.
+ *
+ * The `BookmarkProvider` also supports event listeners for various bookmark-related events, such as when the current bookmark changes or when a bookmark is created, updated, or removed.
+ */
+export declare class BookmarkProvider {
+    #private;
+    /**
+     * Gets the semantic version of the bookmark provider.
+     */
+    get version(): SemanticVersion;
+    get filters(): BookmarkModuleConfig['filters'];
+    /**
+     * Gets the `IBookmarkClient` instance used by this `BookmarkProvider`.
+     */
+    get client(): IBookmarkClient;
+    /**
+     * Gets the currently active bookmark (if any).
+     */
+    get currentBookmark$(): Observable<Bookmark | null>;
+    /**
+     * Gets an observable that emits the current list of bookmarks.
+     */
+    get bookmarks$(): Observable<Array<BookmarkWithoutData>>;
+    /**
+     * Gets the current list of bookmarks.
+     */
+    get bookmarks(): Array<BookmarkWithoutData>;
+    /**
+     * Gets the currently active bookmark.
+     */
+    get currentBookmark(): Bookmark | null | undefined;
+    /**
+     * Represents an observable stream of the bookmark status.
+     */
+    get status$(): Observable<BookmarkState['status']>;
+    /**
+     * Gets an observable that emits 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.
+     */
+    get hasBookmarkCreators(): boolean;
+    /**
+     * Gets the source system value from the configuration.
+     */
+    get sourceSystem(): BookmarkModuleConfig['sourceSystem'];
+    /**
+     * Gets the resolved application from the bookmark module configuration.
+     */
+    get resolvedApplication(): BookmarkModuleConfig['resolve']['application'];
+    /**
+     * Gets the resolved context from the bookmark module configuration.
+     */
+    get resolvedContext(): BookmarkModuleConfig['resolve']['context'];
+    protected get _apiClient(): IBookmarkClient;
+    /**
+     * configured logger instance.
+     */
+    protected get _log(): BookmarkModuleConfig['log'];
+    /**
+     * configured resolvers
+     */
+    protected get _resolve(): BookmarkModuleConfig['resolve'];
+    /**
+     * configured event provider.
+     */
+    protected get _event(): BookmarkModuleConfig['eventProvider'];
+    /**
+     * configured parent bookmark provider
+     */
+    protected get _parent(): BookmarkModuleConfig['parent'];
+    /**
+     * Constructs a new `BookmarkProvider` instance.
+     *
+     * @param config - The configuration for the bookmark module, including the client, initial state, and optional parent provider.
+     */
+    constructor(config: BookmarkModuleConfig);
+    /**
+     * Registers an event listener for the specified event on the BookmarkProvider.
+     *
+     * @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`.
+     * @returns A function that can be called to remove the event listener.
+     */
+    on<TType extends keyof BookmarkProviderEventMap>(eventName: TType, callback: (event: BookmarkProviderEventMap[TType]) => void): VoidFunction;
+    /**
+     * 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.
+     *
+     * @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.
+     */
+    addPayloadGenerator<T extends BookmarkData>(fn: BookmarkPayloadGenerator<T>): VoidFunction;
+    /**
+     * Generates a payload by applying registered generator functions to an accumulator object.
+     *
+     * @param initial - The initial value of the accumulator object.
+     * @returns An observable that emits the generated payload.
+     * @template T - The type of the generated payload.
+     */
+    generatePayload<T extends BookmarkData>(initial?: Partial<T> | null): Observable<T | null | undefined>;
+    /**
+     * Retrieves a bookmark with the specified bookmarkId and returns an observable that emits the combined result of fetching the bookmark and bookmark data.
+     * @template T The type of the bookmark payload.
+     * @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.
+     */
+    getBookmark<T extends BookmarkData>(bookmarkId: string, options?: {
+        excludePayload?: boolean;
+    }): Observable<import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<import("zod").objectUtil.extendShape<{
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+        appKey: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        isShared: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        created: import("zod").ZodDate;
+        createdBy: import("zod").ZodObject<{
+            azureUniqueId: import("zod").ZodString;
+            name: import("zod").ZodString;
+            mail: import("zod").ZodOptional<import("zod").ZodString>;
+            phoneNumber: import("zod").ZodOptional<import("zod").ZodString>;
+            jobTitle: import("zod").ZodOptional<import("zod").ZodString>;
+            accountType: import("zod").ZodOptional<import("zod").ZodEnum<["Employee", "Consultant", "External", "Application", "Local"]>>;
+            accountClassification: import("zod").ZodOptional<import("zod").ZodEnum<["Unclassified", "Internal", "External"]>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            azureUniqueId: string;
+            name: string;
+            mail?: string | undefined;
+            phoneNumber?: string | undefined;
+            jobTitle?: string | undefined;
+            accountType?: "Employee" | "Consultant" | "External" | "Application" | "Local" | undefined;
+            accountClassification?: "External" | "Unclassified" | "Internal" | undefined;
+        }, {
+            azureUniqueId: string;
+            name: string;
+            mail?: string | undefined;
+            phoneNumber?: string | undefined;
+            jobTitle?: string | undefined;
+            accountType?: "Employee" | "Consultant" | "External" | "Application" | "Local" | undefined;
+            accountClassification?: "External" | "Unclassified" | "Internal" | undefined;
+        }>;
+        updated: import("zod").ZodOptional<import("zod").ZodDate>;
+        updatedBy: import("zod").ZodOptional<import("zod").ZodObject<{
+            azureUniqueId: import("zod").ZodString;
+            name: import("zod").ZodString;
+            mail: import("zod").ZodOptional<import("zod").ZodString>;
+            phoneNumber: import("zod").ZodOptional<import("zod").ZodString>;
+            jobTitle: import("zod").ZodOptional<import("zod").ZodString>;
+            accountType: import("zod").ZodOptional<import("zod").ZodEnum<["Employee", "Consultant", "External", "Application", "Local"]>>;
+            accountClassification: import("zod").ZodOptional<import("zod").ZodEnum<["Unclassified", "Internal", "External"]>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            azureUniqueId: string;
+            name: string;
+            mail?: string | undefined;
+            phoneNumber?: string | undefined;
+            jobTitle?: string | undefined;
+            accountType?: "Employee" | "Consultant" | "External" | "Application" | "Local" | undefined;
+            accountClassification?: "External" | "Unclassified" | "Internal" | undefined;
+        }, {
+            azureUniqueId: string;
+            name: string;
+            mail?: string | undefined;
+            phoneNumber?: string | undefined;
+            jobTitle?: string | undefined;
+            accountType?: "Employee" | "Consultant" | "External" | "Application" | "Local" | undefined;
+            accountClassification?: "External" | "Unclassified" | "Internal" | undefined;
+        }>>;
+        context: import("zod").ZodOptional<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            type: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            name?: string | undefined;
+            type?: string | undefined;
+        }, {
+            id: string;
+            name?: string | undefined;
+            type?: string | undefined;
+        }>>;
+        sourceSystem: import("zod").ZodOptional<import("zod").ZodObject<{
+            identifier: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            subSystem: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            identifier: string;
+            name?: string | undefined;
+            subSystem?: string | undefined;
+        }, {
+            identifier: string;
+            name?: string | undefined;
+            subSystem?: string | undefined;
+        }>>;
+    }, {
+        payload: import("zod").ZodType<T, import("zod").ZodTypeDef, T>;
+    }>>, any> extends infer T_1 ? { [k in keyof T_1]: import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<import("zod").objectUtil.extendShape<{
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+        appKey: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        isShared: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        created: import("zod").ZodDate;
+        createdBy: import("zod").ZodObject<{
+            azureUniqueId: import("zod").ZodString;
+            name: import("zod").ZodString;
+            mail: import("zod").ZodOptional<import("zod").ZodString>;
+            phoneNumber: import("zod").ZodOptional<import("zod").ZodString>;
+            jobTitle: import("zod").ZodOptional<import("zod").ZodString>;
+            accountType: import("zod").ZodOptional<import("zod").ZodEnum<["Employee", "Consultant", "External", "Application", "Local"]>>;
+            accountClassification: import("zod").ZodOptional<import("zod").ZodEnum<["Unclassified", "Internal", "External"]>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            azureUniqueId: string;
+            name: string;
+            mail?: string | undefined;
+            phoneNumber?: string | undefined;
+            jobTitle?: string | undefined;
+            accountType?: "Employee" | "Consultant" | "External" | "Application" | "Local" | undefined;
+            accountClassification?: "External" | "Unclassified" | "Internal" | undefined;
+        }, {
+            azureUniqueId: string;
+            name: string;
+            mail?: string | undefined;
+            phoneNumber?: string | undefined;
+            jobTitle?: string | undefined;
+            accountType?: "Employee" | "Consultant" | "External" | "Application" | "Local" | undefined;
+            accountClassification?: "External" | "Unclassified" | "Internal" | undefined;
+        }>;
+        updated: import("zod").ZodOptional<import("zod").ZodDate>;
+        updatedBy: import("zod").ZodOptional<import("zod").ZodObject<{
+            azureUniqueId: import("zod").ZodString;
+            name: import("zod").ZodString;
+            mail: import("zod").ZodOptional<import("zod").ZodString>;
+            phoneNumber: import("zod").ZodOptional<import("zod").ZodString>;
+            jobTitle: import("zod").ZodOptional<import("zod").ZodString>;
+            accountType: import("zod").ZodOptional<import("zod").ZodEnum<["Employee", "Consultant", "External", "Application", "Local"]>>;
+            accountClassification: import("zod").ZodOptional<import("zod").ZodEnum<["Unclassified", "Internal", "External"]>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            azureUniqueId: string;
+            name: string;
+            mail?: string | undefined;
+            phoneNumber?: string | undefined;
+            jobTitle?: string | undefined;
+            accountType?: "Employee" | "Consultant" | "External" | "Application" | "Local" | undefined;
+            accountClassification?: "External" | "Unclassified" | "Internal" | undefined;
+        }, {
+            azureUniqueId: string;
+            name: string;
+            mail?: string | undefined;
+            phoneNumber?: string | undefined;
+            jobTitle?: string | undefined;
+            accountType?: "Employee" | "Consultant" | "External" | "Application" | "Local" | undefined;
+            accountClassification?: "External" | "Unclassified" | "Internal" | undefined;
+        }>>;
+        context: import("zod").ZodOptional<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            type: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            name?: string | undefined;
+            type?: string | undefined;
+        }, {
+            id: string;
+            name?: string | undefined;
+            type?: string | undefined;
+        }>>;
+        sourceSystem: import("zod").ZodOptional<import("zod").ZodObject<{
+            identifier: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            subSystem: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            identifier: string;
+            name?: string | undefined;
+            subSystem?: string | undefined;
+        }, {
+            identifier: string;
+            name?: string | undefined;
+            subSystem?: string | undefined;
+        }>>;
+    }, {
+        payload: import("zod").ZodType<T, import("zod").ZodTypeDef, T>;
+    }>>, any>[k]; } : never>;
+    /**
+     * Retrieves a bookmark asynchronously.
+     *
+     * @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.
+     * @returns A promise that resolves to the retrieved bookmark, or null if the bookmark is not found.
+     */
+    getBookmarkAsync<T extends BookmarkData>(id: string, options?: {
+        excludePayload?: boolean;
+    }): Promise<Bookmark<T> | null>;
+    /**
+     * Asynchronously retrieves all bookmarks from the store.
+     *
+     * @returns A Promise that resolves to the Bookmarks object containing all bookmarks.
+     */
+    getAllBookmarks(): Observable<Bookmarks>;
+    /**
+     * Asynchronously retrieves all bookmarks from the store.
+     *
+     * @returns A Promise that resolves to the Bookmarks object containing all bookmarks.
+     */
+    getAllBookmarksAsync(): Promise<Bookmarks>;
+    /**
+     * Sets the current bookmark to the specified bookmark or ID.
+     * If the bookmark is already the current bookmark, it returns the bookmark directly.
+     * Otherwise, it emits the next bookmark or null through an observable.
+     *
+     * By proving `null` as the bookmark_or_id, the current bookmark will be cleared.
+     *
+     * @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.
+     */
+    setCurrentBookmark<T extends BookmarkData = any>(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.
+     *
+     * 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.
+     */
+    setCurrentBookmarkAsync<T extends BookmarkData>(bookmark_or_id: Bookmark<T> | string | null): Promise<Bookmark<T> | null>;
+    /**
+     * Creates a new bookmark with the provided bookmark data.
+     * @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.
+     */
+    createBookmark<T extends BookmarkData>(newBookmarkData: BookmarkCreateArgs<T>): Observable<Bookmark<T>>;
+    /**
+     * Asynchronously creates a new bookmark.
+     *
+     * @param bookmark - The new bookmark to create.
+     * @returns A promise that resolves to the created bookmark with its associated data.
+     */
+    createBookmarkAsync<T extends BookmarkData>(args: BookmarkCreateArgs<T>): Promise<Bookmark<T>>;
+    /**
+     * Updates a bookmark with the specified bookmarkId and bookmarkUpdates.
+     *
+     * @template T - The type of the bookmark data.
+     * @param {string} bookmarkId - The identifier of the bookmark to update.
+     * @param {BookmarkUpdate<T>} [bookmarkUpdates] - The updates to apply to the bookmark.
+     * @param {BookmarkUpdateOptions} [options] - The options for updating the bookmark.
+     * @returns {Promise<Bookmark<T>>} - A promise that resolves to the updated bookmark.
+     */
+    updateBookmark<T extends BookmarkData>(bookmarkId: string, bookmarkUpdates?: BookmarkUpdate<T>, options?: BookmarkUpdateOptions): Observable<Bookmark<T>>;
+    /**
+     * Updates a bookmark asynchronously.
+     *
+     * @param bookmark - The bookmark to update.
+     * @returns A promise that resolves to the updated bookmark with its associated data.
+     */
+    updateBookmarkAsync<T extends BookmarkData>(bookmarkId: string, bookmarkUpdates?: BookmarkUpdate<T>, options?: BookmarkUpdateOptions): Promise<Bookmark<T>>;
+    /**
+     * Deletes a bookmark with the specified bookmarkId.
+     *
+     * @param bookmarkId - The unique identifier of the bookmark to be deleted.
+     * @returns A Promise that resolves when the bookmark is successfully deleted.
+     * @throws {BookmarkProviderError} If there is an error deleting the bookmark.
+     */
+    deleteBookmark(bookmarkId: string): Observable<void>;
+    /**
+     * Deletes a bookmark asynchronously.
+     *
+     * @param bookmarkId - The ID of the bookmark to delete.
+     * @returns A Promise that resolves when the bookmark is deleted.
+     */
+    deleteBookmarkAsync(bookmarkId: string): Promise<void>;
+    /**
+     * Adds a bookmark to the 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.
+     */
+    addBookmarkToFavorites(bookmarkId: string): Observable<BookmarkWithoutData | undefined>;
+    /**
+     * Asynchronously adds a bookmark to the user's favorites.
+     *
+     * @param bookmarkId - The ID of the bookmark to add to the user's favorites.
+     * @returns A Promise that resolves to the added Bookmark, or null if the operation failed.
+     */
+    addBookmarkToFavoritesAsync(bookmarkId: string): Promise<Bookmark | undefined>;
+    /**
+     * Removes a bookmark as a favorite.
+     *
+     * @param bookmarkId - The ID of the bookmark to remove as a favorite.
+     * @returns A Promise that resolves when the bookmark is successfully removed as a favorite.
+     * @throws {BookmarkProviderError} If the event is canceled or if there is a failure in removing the bookmark as a favorite.
+     */
+    removeBookmarkAsFavorite(bookmarkId: string): Observable<void>;
+    /**
+     * Removes a bookmark as a favorite asynchronously.
+     *
+     * @param bookmarkId - The ID of the bookmark to remove as a favorite.
+     * @returns A Promise that resolves when the bookmark is successfully removed as a favorite.
+     */
+    removeBookmarkAsFavoriteAsync(bookmarkId: string): Promise<void>;
+    /**
+     * 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.
+     */
+    isBookmarkInFavorites(bookmarkId: string): Observable<boolean>;
+    /**
+     * Checks if the specified bookmark is in the user's 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 user's favorites.
+     */
+    isBookmarkInFavoritesAsync(bookmarkId: string): Promise<boolean>;
+    protected _getBookmarkInfo(bookmarkId: string, options?: {
+        timeout?: number;
+    }): Observable<BookmarkWithoutData>;
+    protected _getBookmarkData<T extends BookmarkData>(bookmarkId: string, options?: {
+        timeout?: number;
+    }): Observable<T | null>;
+    /**
+     * Dispatches an event of the specified type with the provided arguments.
+     *
+     * @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>]>;
+    protected _useScopedActions<TAction extends BookmarkActions>(ref?: string): {
+        ref: string;
+        action$: Observable<TAction>;
+    };
+    /**
+     * Disposes the BookmarkProvider.
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,9 @@
+import { type ActionWithSuffix } from '@equinor/fusion-observable';
+import { BookmarkActions } from './BookmarkProvider.actions';
+export declare class BookmarkFlowError extends Error {
+    readonly action: ActionWithSuffix<BookmarkActions, 'request'>;
+    constructor(message: string, action: ActionWithSuffix<BookmarkActions, 'request'>, options?: ErrorOptions);
+}
+export declare class BookmarkProviderError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}

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

@@ -0,0 +1,78 @@
+import type { FrameworkEventInit, IFrameworkEvent } from '@equinor/fusion-framework-module-event';
+import type { Bookmark } from './types';
+import type { BookmarkPayloadGenerator, BookmarkProvider } from './BookmarkProvider';
+import { BookmarkNew, BookmarkUpdate } from './BookmarkClient.interface';
+export interface BookmarkProviderEventMap {
+    /**
+     * An event that is emitted before current bookmark is changed.
+     */
+    onCurrentBookmarkChange: IFrameworkEvent<FrameworkEventInit<{
+        current?: Bookmark | null;
+        next: Bookmark | null;
+    }, BookmarkProvider>>;
+    /**
+     * An event that is emitted when the current bookmark has changed.
+     */
+    onCurrentBookmarkChanged: IFrameworkEvent<FrameworkEventInit<Bookmark | null, BookmarkProvider>>;
+    /**
+     * An event that is emitted before a bookmark is created.
+     */
+    onBookmarkCreate: IFrameworkEvent<FrameworkEventInit<BookmarkNew, BookmarkProvider>>;
+    /**
+     * An event that is emitted when a bookmark has been created.
+     */
+    onBookmarkCreated: IFrameworkEvent<FrameworkEventInit<Bookmark, BookmarkProvider>>;
+    /**
+     * An event that is emitted before a bookmark is updated.
+     */
+    onBookmarkUpdate: IFrameworkEvent<FrameworkEventInit<{
+        current?: Bookmark;
+        updates: BookmarkUpdate;
+    }, BookmarkProvider>>;
+    /**
+     * An event that is emitted before a bookmark is updated.
+     */
+    onBookmarkUpdated: IFrameworkEvent<FrameworkEventInit<Bookmark, BookmarkProvider>>;
+    /**
+     * An event that is emitted before a bookmark is removed.
+     */
+    onBookmarkDelete: IFrameworkEvent<FrameworkEventInit<{
+        id: string;
+    }, BookmarkProvider>>;
+    /**
+     * An event that is emitted before a bookmark is removed.
+     */
+    onBookmarkDeleted: IFrameworkEvent<FrameworkEventInit<{
+        id: string;
+    }, BookmarkProvider>>;
+    /**
+     * An event that is emitted before a bookmark is added to the user's favorites.
+     */
+    onBookmarkFavouriteRemove: IFrameworkEvent<FrameworkEventInit<{
+        id: string;
+    }, BookmarkProvider>>;
+    /**
+     * An event that is emitted when a bookmark is removed from the user's favorites.
+     */
+    onBookmarkFavouriteRemoved: IFrameworkEvent<FrameworkEventInit<{
+        id: string;
+    }, BookmarkProvider>>;
+    /**
+     * An event that is emitted before a bookmark is added to the user's favorites.
+     */
+    onBookmarkFavouriteAdd: IFrameworkEvent<FrameworkEventInit<{
+        id: string;
+    }, BookmarkProvider>>;
+    /**
+     * An event that is emitted when a bookmark is added to the user's favorites.
+     */
+    onBookmarkFavouriteAdded: IFrameworkEvent<FrameworkEventInit<Bookmark | undefined, BookmarkProvider>>;
+    /**
+     * An event that is emitted when a new bookmark payload generator is added.
+     */
+    onBookmarkPayloadCreatorAdded: IFrameworkEvent<FrameworkEventInit<BookmarkPayloadGenerator, BookmarkProvider>>;
+}
+declare module '@equinor/fusion-framework-module-event' {
+    interface FrameworkEventMap extends BookmarkProviderEventMap {
+    }
+}

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

@@ -0,0 +1,79 @@
+import { type Flow } from '@equinor/fusion-observable';
+import { type BookmarkActions } from './BookmarkProvider.actions';
+import type { IBookmarkClient } from './BookmarkClient.interface';
+import type { BookmarkState } from './BookmarkProvider.store';
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * Creates a Flow for handling fetching users bookmarks.
+ *
+ * @param api - The bookmark API client to use for fetching bookmarks.
+ * @param options - Optional configuration options, including a `throttle` value in milliseconds.
+ * @returns An observable that emits the result of the bookmark fetch operation.
+ */
+export declare const handleFetchAllBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * Creates a Flow for handling deleting bookmarks.
+ *
+ * @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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;