@equinor/fusion-framework-module-bookmark 4.1.0 → 4.1.2

package/src/BookmarkModuleConfigurator.ts

@@ -1,412 +0,0 @@
-import type { ZodError } from 'zod';
-
-import {
-  BaseConfigBuilder,
-  type ConfigBuilderCallback,
-  type ConfigBuilderCallbackArgs,
-  type ModulesInstanceType,
-} from '@equinor/fusion-framework-module';
-
-import type { IApiProvider, ServicesModule } from '@equinor/fusion-framework-module-services';
-import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
-import type { ILogger, LogLevel } from '@equinor/fusion-log';
-
-import { BookmarkClient } from './BookmarkClient';
-import type { BookmarkModule } from './bookmark-module';
-import { bookmarkConfigSchema, parseBookmarkConfig } from './bookmark-config.schema';
-import type { BookmarkModuleConfig } from './types';
-import type { BookmarkProvider } from './BookmarkProvider';
-
-const initialBookmarkConfig = bookmarkConfigSchema
-  .pick({
-    filters: true,
-    sourceSystem: true,
-    resolve: true,
-  })
-  .partial()
-  .optional();
-
-const parseInitialBookmarkConfigConfig = (initial?: unknown): BookmarkModuleConfig => {
-  return initialBookmarkConfig.parse(initial) as BookmarkModuleConfig;
-};
-
-/**
- * Configurator for the bookmark module.
- *
- * Provides a builder-style API for setting the source system, bookmark client,
- * context/application resolvers, filters, and parent provider before the module
- * is initialised. Extends {@link BaseConfigBuilder} and produces a validated
- * {@link BookmarkModuleConfig} at build time.
- *
- * In most cases you interact with this class through the callback provided to
- * {@link enableBookmark} rather than instantiating it directly.
- */
-export class BookmarkModuleConfigurator extends BaseConfigBuilder<BookmarkModuleConfig> {
-  #log?: ILogger;
-  /** Default expiration time, in milliseconds, for bookmarks. */
-  defaultExpireTime = 1 * 60 * 1000;
-
-  /**
-   * 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]> }) {
-    super();
-    const { log } = options ?? {};
-    this.#log = log;
-    this._set('log', async () => log);
-  }
-
-  /**
-   * Sets the log level for the bookmark configurator.
-   *
-   * @param level - The log level to set. Allowed values are:
-   * - 0: No logging
-   * - 1: Error messages only
-   * - 2: Error and warning messages
-   * - 3: Error, warning, and info messages
-   * - 4: Error, warning, info, and debug messages
-   */
-  public setLogLevel(level: LogLevel) {
-    this._set('logLevel', async () => level);
-    // propagate the level to the configurator's own logger, if one is set
-    if (this.#log) {
-      this.#log.level = level;
-    }
-  }
-
-  /**
-   * Sets the client for interacting with bookmark operations.
-   * The client argument can be either a client object with predefined methods for bookmark operations or a callback function that creates and returns such a client object.
-   * This method enables the configuration of how the bookmark module interacts with the backend or any other service to perform operations such as getting, creating, or updating bookmarks.
-   *
-   * @param client A client object or a callback function that returns a client object.
-   * - If a callback function is provided, it receives an initializer function as its argument,
-   *   and it should return a Promise that resolves to a client object.
-   * - If a client object is provided directly, it is wrapped in a Promise and used as-is.
-   *
-   * @see {@link BookmarkModuleConfig.client}
-   */
-  public setClient(
-    client: ConfigBuilderCallback<BookmarkModuleConfig['client']> | BookmarkModuleConfig['client'],
-  ) {
-    // a callback receives the module initializer and resolves the client itself
-    if (typeof client === 'function') {
-      this._set('client', (init) => client(init));
-    } else {
-      this._set('client', async () => client);
-    }
-  }
-
-  /**
-   * Sets the parent configuration for the bookmark module.
-   * This allows the bookmark module to inherit configuration from a parent module.
-   *
-   * @param parent - A callback function or a configuration object that provides the parent configuration.
-   * - If a callback function is provided, it receives an initializer function as its argument and should return a Promise that resolves to the parent configuration object.
-   * - If a configuration object is provided directly, it is wrapped in a Promise and used as-is.
-   */
-  public setParent(
-    parent: ConfigBuilderCallback<BookmarkModuleConfig['parent']> | BookmarkModuleConfig['parent'],
-  ) {
-    // a callback receives the module initializer and resolves the parent itself
-    if (typeof parent === 'function') {
-      this._set('parent', (init) => parent(init));
-    } else {
-      this._set('parent', async () => parent);
-    }
-  }
-
-  /**
-   * Set the source system for the bookmark module.
-   * This is used to tag bookmarks with their originating system for filtering or categorization purposes.
-   * @param sourceSystem - A callback function that returns the source system or a string value of the source system.
-   *
-   * Example:
-   * ```
-   * configurator.setSourceSystem('MyApplication');
-   * ```
-   * or
-   * ```
-   * configurator.setSourceSystem((init) => 'MyApplication');
-   * ```
-   */
-  public setSourceSystem(
-    sourceSystem:
-      | ConfigBuilderCallback<BookmarkModuleConfig['sourceSystem']>
-      | BookmarkModuleConfig['sourceSystem'],
-  ) {
-    // a callback receives the module initializer and resolves the source system itself
-    if (typeof sourceSystem === 'function') {
-      this._set('sourceSystem', sourceSystem);
-    } else {
-      this._set('sourceSystem', async () => sourceSystem);
-    }
-  }
-
-  /**
-   * Set the context ID resolver for the bookmark module.
-   * This function is used to resolve the context ID dynamically, allowing for context-aware bookmark operations.
-   * @param cb - A callback function that returns the context ID resolver function.
-   *
-   * Example:
-   * ```
-   * configurator.setContextIdResolver((init) => () => 'currentContextId');
-   * ```
-   */
-  public setContextResolver(cb: ConfigBuilderCallback<BookmarkModuleConfig['resolve']['context']>) {
-    this._set('resolve.context', cb);
-  }
-
-  /**
-   * Set the application key resolver for the bookmark module.
-   * This function is used to resolve the application key dynamically, providing a way to associate bookmarks with specific applications.
-   * @param cb - A callback function that returns the application key resolver function.
-   *
-   * Example:
-   * ```
-   * configurator.setApplicationKeyResolver((init) => () => 'myApplicationKey');
-   * ```
-   */
-  public setApplicationResolver(
-    cb: ConfigBuilderCallback<BookmarkModuleConfig['resolve']['application']>,
-  ) {
-    this._set('resolve.application', cb);
-  }
-
-  /**
-   * 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.
-   *
-   * Applied when fetching bookmarks
-   * - application: Only return bookmarks for the resolved application.
-   * - context: Only return bookmarks for the resolved context.
-   */
-  public setFilter<TKey extends keyof BookmarkModuleConfig['filters']>(
-    key: TKey,
-    value: BookmarkModuleConfig['filters'][TKey],
-  ) {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-expect-error
-    this._set(`filters.${key}`, async () => value);
-  }
-
-  /**
-   * Will set default configuration:
-   * - `client` - a default client is set
-   * - `resolveContextId` - a default context resolver is set
-   * - `resolveApplicationKey` - a default application key resolver is set
-   * - `sourceSystem` - a default source system is set
-   * @internal method to create config, will apply defaults if not provided during build of config.
-   * @param init - The config builder callback args.
-   * @param initial - An optional initial config to merge into the returned config.
-   * @returns The config object.
-   */
-  protected _createConfig(
-    init: ConfigBuilderCallbackArgs,
-    initial?: Partial<BookmarkModuleConfig>,
-  ) {
-    // check if parent is provided
-    if (!this._has('parent')) {
-      this.#log?.debug('No parent provided, using default parent');
-
-      // Check if parent and parent version compatible
-      const parentModules = init.ref as ModulesInstanceType<[BookmarkModule]>;
-      // only use the parent module's bookmark provider if it's actually present
-      if (parentModules && 'bookmark' in parentModules) {
-        const parent = parentModules.bookmark;
-        // `parent` is narrowed to `{ version: unknown }` by the `'version' in parent` check below,
-        // so it must be cast through `unknown` to access `BookmarkProvider`-specific members.
-        const parentProvider = parent as unknown as BookmarkProvider;
-        // only inherit from a parent whose version satisfies the minimum supported range
-        if ('version' in parent && parentProvider.version.satisfies('>=2.0.0')) {
-          this._set('parent', async () => parent);
-        } else {
-          this.#log?.warn('invalid version of parent BookmarkProvider provided');
-        }
-      } else {
-        this.#log?.info('No parent BookmarkProvider found');
-      }
-    }
-
-    // Ensure a default client is set if none is provided
-    if (!this._has('client')) {
-      this.#log?.debug('No client provided, using default client');
-      this._set('client', this._createDefaultClient.bind(this));
-    }
-
-    // Ensure a default context resolver is set if none is provided
-    if (!this._has('resolve.context')) {
-      this.#log?.debug('No context resolver provided, using default context resolver');
-      this._set('resolve.context', this._createDefaultContextResolver.bind(this));
-    }
-
-    // Ensure a default application resolver is set if none is provided
-    if (!this._has('resolve.application')) {
-      this.#log?.debug('No application resolver provided, using default application resolver');
-      this._set('resolve.application', this._createDefaultApplicationResolver.bind(this));
-    }
-
-    // Ensure a default event provider is set if none is provided
-    if (!this._has('eventProvider')) {
-      this.#log?.debug('No event provider provided, using default event provider');
-      this._set('eventProvider', this._resolveEventProvider.bind(this));
-    }
-
-    // call super to create config
-    return super._createConfig(init, parseInitialBookmarkConfigConfig(initial));
-  }
-
-  /**
-   * @internal Create a default context resolver for the bookmark module.
-   * @param init - The configuration initialization object.
-   * @returns A function that resolves the current context ID, or undefined if no context module is available.
-   */
-  protected async _createDefaultContextResolver(
-    init: ConfigBuilderCallbackArgs,
-  ): Promise<BookmarkModuleConfig['resolve']['context'] | undefined> {
-    // Check if context module is available and use context provider if available
-    if (init.hasModule('context')) {
-      this.#log?.debug('Context module available, awaiting instance');
-      const contextProvider = await init.requireInstance('context');
-
-      this.#log?.debug('Context provider available, creating context resolver');
-      return async () => {
-        this.#log?.debug('Resolving context for bookmarks');
-        const id = contextProvider.currentContext?.id;
-        return id ? { id } : undefined;
-      };
-    }
-  }
-
-  /**
-   * @internal Create a default application resolver for the bookmark module.
-   * @param init - The configuration initialization object.
-   * @returns A function that resolves the current application key, or undefined if no app module is available.
-   */
-  protected async _createDefaultApplicationResolver(
-    init: ConfigBuilderCallbackArgs,
-  ): Promise<BookmarkModuleConfig['resolve']['application'] | undefined> {
-    // Check if app module is available and use app provider if available
-    if (init.hasModule('app')) {
-      this.#log?.debug('App module available, awaiting instance');
-      const appProvider = await init.requireInstance('app');
-
-      this.#log?.debug('App provider available, creating application resolver');
-      return async () => {
-        const app = appProvider.current;
-        // only resolve the application if there is a currently loaded app
-        if (app) {
-          return {
-            appKey: app.appKey,
-            name: app.manifest?.name,
-          };
-        }
-        this.#log?.warn('No current application found');
-        return undefined;
-      };
-    }
-  }
-
-  /**
-   * @internal Resolves the {@link AppModuleProvider} for the bookmark module.
-   * @param init - The configuration initialization object.
-   * @returns A promise that resolves to the app module provider, or undefined if unavailable.
-   */
-  protected async _resolveAppProvider(
-    init: ConfigBuilderCallbackArgs,
-  ): Promise<AppModuleProvider | undefined> {
-    // Check if app module is available
-    if (init.hasModule('app')) {
-      this.#log?.debug('App module available, awaiting instance');
-      return init.requireInstance('app');
-    }
-    this.#log?.debug('No app module available, will use ref to app module if available');
-    return undefined;
-  }
-
-  /**
-   * @internal Create a default event provider for the bookmark module.
-   * @param init - The configuration initialization object.
-   * @returns A promise that resolves to the default event provider.
-   */
-  protected async _resolveEventProvider(
-    init: ConfigBuilderCallbackArgs,
-  ): Promise<BookmarkModuleConfig['eventProvider'] | undefined> {
-    // Check if event module is available
-    if (init.hasModule('event')) {
-      this.#log?.debug('Event module available, awaiting instance');
-      return init.requireInstance('event');
-    }
-  }
-
-  /**
-   * @internal Create a default client for the bookmark module.
-   * @param init - The configuration initialization object.
-   * @returns A promise that resolves to the default client.
-   */
-  protected async _createDefaultClient(
-    init: ConfigBuilderCallbackArgs,
-  ): Promise<BookmarkModuleConfig['client'] | undefined> {
-    try {
-      const apiProvider = await this._getServiceProvider(init);
-      const api = await apiProvider.createBookmarksClient('json$');
-      return new BookmarkClient(api);
-    } catch (_err) {
-      this.#log?.warn('Failed to create bookmark api client');
-    }
-  }
-
-  /**
-   * @internal retrieves the service provider from the configuration initialization object.
-   * @param init - The configuration initialization object.
-   * @returns A promise that resolves to the service provider.
-   * @throws {Error} When no services module or parent service module is available.
-   */
-  protected async _getServiceProvider(init: ConfigBuilderCallbackArgs): Promise<IApiProvider> {
-    // check if services module is available
-    if (init.hasModule('services')) {
-      this.#log?.debug('Services module available, awaiting instance');
-      return init.requireInstance('services');
-    }
-
-    this.#log?.debug('No services module available, will use ref services module if available');
-
-    // check if parent has services module
-    const parentServiceModule = (init.ref as ModulesInstanceType<[ServicesModule]>)?.services;
-    // reuse the parent's service module if one is available
-    if (parentServiceModule) {
-      return parentServiceModule;
-    }
-
-    // No service provider available
-    this.#log?.error('No service provider available, cannot create bookmarks client');
-    throw Error('[BookmarkConfigurator] No service provider configures [ServicesModule] ');
-  }
-
-  /**
-   * @internal Validates and normalizes the resolved config before it's returned from `build`.
-   * @param config - The partially-resolved bookmark module config.
-   * @param _init - The configuration initialization object (unused).
-   * @returns The validated {@link BookmarkModuleConfig}.
-   * @throws {ZodError} When the config fails schema validation.
-   */
-  protected async _processConfig(
-    config: Partial<BookmarkModuleConfig>,
-    _init: ConfigBuilderCallbackArgs,
-  ): Promise<BookmarkModuleConfig> {
-    try {
-      return parseBookmarkConfig(config);
-    } catch (err) {
-      this.#log?.error('Failed to parse config', config, (err as ZodError).issues ?? err);
-      throw err;
-    }
-  }
-}
-
-export default BookmarkModuleConfigurator;

package/src/BookmarkProvider.events.ts

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

package/src/BookmarkProvider.interface.ts

@@ -1,180 +0,0 @@
-// biome-ignore-all lint/suspicious/noExplicitAny: `BookmarkData = any` generic defaults must remain bivariant — `unknown` breaks assignability of concrete `Bookmark<T>`/`BookmarkPayloadGenerator<TData>` instances to the default-typed generic
-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 './create-bookmark-store';
-
-/**
- * Arguments for creating a bookmark via {@link IBookmarkProvider.createBookmark}.
- *
- * Omits fields that the provider resolves automatically (`appKey`, `contextId`, `sourceSystem`),
- * but allows the caller to override `appKey` if needed.
- *
- * @template T - The type of payload data stored in the bookmark.
- */
-export type BookmarkCreateArgs<T extends BookmarkData = any> = Omit<
-  BookmarkNew<T>,
-  'appKey' | 'contextId' | 'sourceSystem'
-> &
-  Partial<Pick<BookmarkNew<T>, 'appKey'>>;
-
-/**
- * Options that control how {@link IBookmarkProvider.updateBookmark} processes an update.
- *
- * @property excludePayloadGeneration - When `true`, skip running registered payload generators
- *   and send the update payload as-is. Useful when the caller has already computed the full payload.
- */
-export type BookmarkUpdateOptions = {
-  excludePayloadGeneration?: boolean;
-};
-
-/**
- * Callback registered with {@link IBookmarkProvider.addPayloadGenerator} that participates
- * in building or transforming bookmark payload data during create and update operations.
- *
- * The `payload` argument is an Immer draft — mutate it in place rather than returning a new
- * object. If the generator returns a value it will be used, but this is discouraged.
- * Return `null` to signal that the bookmark payload should be cleared.
- *
- * @template TData - Shape of the bookmark payload.
- * @param payload - The accumulated payload draft from previous generators (mutable).
- * @param initial - The original payload before any generators ran (read-only reference).
- * @returns A partial payload, `void` (when mutating the draft), or `null` to clear.
- */
-export type BookmarkPayloadGenerator<TData extends BookmarkData = any> = (
-  payload?: Partial<TData> | null,
-  initial?: Partial<TData> | null,
-  // biome-ignore lint/suspicious/noConfusingVoidType: `void` here relies on TypeScript's special-cased "void-returning callback accepts any return value" behavior for draft-mutating generators — `undefined` would break assignability of generators that only conditionally return a partial payload
-) => Promise<Partial<TData> | void> | Partial<TData> | void;
-
-/**
- * Interface representing a Bookmark Provider.
- */
-export interface IBookmarkProvider {
-  readonly currentBookmark: Bookmark | null | undefined;
-  /**
-   * Observable of the current bookmark.
-   *
-   * @type {ObservableInput<Bookmark | null | undefined>}
-   */
-  readonly currentBookmark$: Observable<Bookmark | null | undefined>;
-
-  readonly bookmarks$: Observable<BookmarkWithoutData[]>;
-
-  /**
-   * Observable status of the bookmark provider.
-   */
-  readonly status$: Observable<BookmarkState['status']>;
-
-  /**
-   * Indicates whether the user can create bookmarks.
-   * If no payload generator is provided, this will always be false.
-   *
-   * @type {boolean}
-   */
-  readonly canCreateBookmarks: boolean;
-
-  /**
-   * fetch a bookmark by its ID.
-   *
-   * @param {string} bookmarkId - The ID of the bookmark to fetch.
-   * @returns {ObservableInput<Bookmark>} An observable input of the bookmark.
-   */
-  getBookmark(bookmarkId: string): ObservableInput<Bookmark>;
-
-  /**
-   * Fetches all bookmarks.
-   *
-   * @returns {ObservableInput<Bookmark[]>} An observable input of the bookmarks.
-   */
-  getAllBookmarks(): ObservableInput<Bookmark[]>;
-
-  /**
-   * Sets the current bookmark.
-   *
-   * @param {Bookmark | string | null} bookmark_or_id - The bookmark or its ID to set as current.
-   * @returns {ObservableInput<Bookmark | null>} An observable input of the current bookmark.
-   */
-  setCurrentBookmark(bookmark_or_id: Bookmark | string | null): ObservableInput<Bookmark | null>;
-
-  /**
-   * Creates a new bookmark.
-   *
-   * @param {BookmarkCreateArgs} newBookmarkData - The data for the new bookmark.
-   * @returns {ObservableInput<Bookmark>} An observable input of the created bookmark.
-   */
-  createBookmark(newBookmarkData: BookmarkCreateArgs): ObservableInput<Bookmark>;
-
-  /**
-   * Updates an existing bookmark.
-   *
-   * @param {string} bookmarkId - The ID of the bookmark to update.
-   * @param {BookmarkUpdate} [bookmarkUpdates] - The updates to apply to the bookmark.
-   * @param {BookmarkUpdateOptions} [options] - Additional options for the update.
-   * @returns {ObservableInput<Bookmark>} An observable input of the updated bookmark.
-   */
-  updateBookmark(
-    bookmarkId: string,
-    bookmarkUpdates?: BookmarkUpdate,
-    options?: BookmarkUpdateOptions,
-  ): ObservableInput<Bookmark>;
-
-  /**
-   * Deletes a bookmark.
-   *
-   * @param {string} bookmarkId - The ID of the bookmark to delete.
-   * @returns {ObservableInput<void>} An observable input indicating the deletion.
-   */
-  deleteBookmark(bookmarkId: string): ObservableInput<void>;
-
-  /**
-   * Adds a bookmark to the favorites.
-   *
-   * @param {string} bookmarkId - The ID of the bookmark to add to favorites.
-   * @returns {ObservableInput<void>} An observable input indicating the addition.
-   */
-  addBookmarkToFavorites(bookmarkId: string): ObservableInput<BookmarkWithoutData | undefined>;
-
-  /**
-   * Removes a bookmark from the favorites.
-   *
-   * @param {string} bookmarkId - The ID of the bookmark to remove from favorites.
-   * @returns {ObservableInput<void>} An observable input indicating the removal.
-   */
-  removeBookmarkAsFavorite(bookmarkId: string): ObservableInput<void>;
-
-  /**
-   * Checks if a bookmark is in the favorites.
-   *
-   * @param bookmarkId
-   * @returns {ObservableInput<boolean>} An observable input indicating whether the bookmark is in the favorites.
-   */
-  isBookmarkInFavorites(bookmarkId: string): ObservableInput<boolean>;
-
-  /**
-   * Registers a payload generator that runs during bookmark create and update operations.
-   *
-   * Multiple generators can be registered and they execute sequentially, each receiving
-   * the accumulated payload from previous generators.
-   *
-   * @template TData - Shape of the bookmark payload.
-   * @param generator - The generator callback to register.
-   * @returns A disposal function that unregisters the generator when called.
-   */
-  addPayloadGenerator<TData extends BookmarkData>(
-    generator: BookmarkPayloadGenerator<TData>,
-  ): VoidFunction;
-
-  /**
-   * Registers an event listener for bookmark provider events.
-   *
-   * @param {TType} eventName - The name of the event to listen for.
-   * @param {(event: BookmarkProviderEventMap[TType]) => void} callback - The callback to invoke when the event is triggered.
-   * @returns {VoidFunction} A function to unregister the event listener.
-   */
-  on<TType extends keyof BookmarkProviderEventMap>(
-    eventName: TType,
-    callback: (event: BookmarkProviderEventMap[TType]) => void,
-  ): VoidFunction;
-}