@equinor/fusion-framework-module-services 4.1.5 → 5.0.0

package/dist/types/types.d.ts

@@ -1,5 +1,19 @@
-import { ClientRequestInit, IHttpClient, StreamResponse, BlobResult, FetchResponse } from '@equinor/fusion-framework-module-http/client';
+import { ClientRequestInit, IHttpClient, StreamResponse, BlobResult } from '@equinor/fusion-framework-module-http/client';
+/**
+ * A factory function that creates an instance of an HTTP client.
+ *
+ * @param name - The name of the HTTP client to create.
+ * @returns A Promise that resolves to an instance of the HTTP client.
+ */
 export type ApiClientFactory<TClient extends IHttpClient = IHttpClient> = (name: string) => Promise<TClient>;
+/**
+ * Represents the arguments for an API client function.
+ *
+ * @template TClient - The type of the HTTP client used by the API client.
+ * @template TResult - The type of the result returned by the API client.
+ * @param path - The path of the API endpoint.
+ * @param init - Optional initialization options for the API client request.
+ */
 export type ApiClientArguments<TClient extends IHttpClient, TResult = unknown> = [
     path: string,
     init?: ClientRequestInit<TClient, TResult>
@@ -8,20 +22,10 @@ export type ApiClientArguments<TClient extends IHttpClient, TResult = unknown> =
  * Execute methods on the IHttpClient
  */
 export type ClientMethod<T = unknown> = {
-    /**
-     * Fetch data async
-     * NOTE: data needs to be extracted from the response
-     */
-    fetch: Promise<FetchResponse<T>>;
     /**
      * Fetch JSON data from a service
      */
     json: Promise<T>;
-    /**
-     * Fetch data as an observable
-     * NOTE: data needs to be extracted from the response
-     */
-    fetch$: StreamResponse<FetchResponse<T>>;
     /**
      * Fetch JSON data from a service as observable
      */
@@ -32,3 +36,62 @@ export type ClientDataMethod<T extends BlobResult = BlobResult> = {
     blob$: StreamResponse<T>;
 };
 export type ClientMethodType = keyof ClientMethod;
+/**
+ * Utility type that filters the keys of an `AvailableTypes` object to only those
+ * whose values are a subset of the `AllowedTypes` string.
+ *
+ * This can be useful for creating a type that represents a subset of an API's
+ * available versions, where the allowed versions are a subset of the total
+ * available versions.
+ *
+ * @example
+ * ```typescript
+ * enum ApiVersions = {
+ *  v1: '1.0'
+ *  v2: '2.0'
+ *  v3: '3.0'
+ * }
+ *
+ * type Services = {
+ *  [ApiVersions.v1]: { request: ApiRequestModel_v1, response: ApiResponseModel_v1 }
+ *  [ApiVersions.v2]: { request: ApiRequestModel_v2, response: ApiResponseModel_v2 }
+ * }
+ *
+ * type ApiServiceVersions = keyof Services; // '1.0' | '2.0'
+ * type AllowedApiVersions = FilterAllowApiVersions<ApiVersions, ApiServiceVersions> // ApiVersions.v1 | 'v1' | ApiVersions.v2 | v2'
+ *
+ * const execute<TVersion extends AllowedApiVersions>(
+ *   version: TVersion,
+ *   args: Services[TVersion]['request']
+ * ): Services[TVersion]['response'] {
+ *      const apiVersion = version in ApiVersion ? ApiVersion[version] : version;
+ *      switch (apiVersion) {
+ *          case ApiVersion.v1:
+ *          case ApiVersion.v2:
+ *              return fetch(args);
+ *      }
+ *     throw new Error('Invalid version');
+ * }
+ *
+ * execute('v1', { id: '123' }); // OK
+ * execute('v3', { id: '123' }); // Error
+ * ```
+ *
+ * @template TAvailableTypes - An object type that maps string keys to string values,
+ *   representing the available API versions.
+ * @template TAllowedTypes - A string union type representing the allowed API versions.
+ * @returns A string union type containing the keys from `AvailableTypes` whose
+ *   values are a subset of `AllowedTypes`.
+ */
+export type FilterAllowedApiVersions<TAvailableTypes extends Record<string, string>, TAllowedTypes extends string | number | symbol = keyof TAvailableTypes> = {
+    [K in keyof TAvailableTypes]: TAvailableTypes extends Record<K, infer V> ? K extends TAllowedTypes ? K | V : V extends TAllowedTypes ? V | K : never : never;
+}[keyof TAvailableTypes];
+/**
+ * Extracts the API version from a set of available types, based on a list of allowed types.
+ *
+ * @template TAvailableTypes - An object mapping API version strings to their corresponding types.
+ * @template TAllowedTypes - A list of allowed API version strings.
+ * @template TVersion - The API version to extract.
+ * @returns The API version type if it is available and allowed, otherwise `never`.
+ */
+export type ExtractApiVersion<TAvailableTypes extends Record<string, string>, TVersion extends string, TAllowedTypes extends string | number | symbol = FilterAllowedApiVersions<TAvailableTypes>> = TVersion extends keyof TAvailableTypes ? TAvailableTypes[TVersion] : TVersion extends TAllowedTypes ? TVersion : never;

package/dist/types/utils.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { type ResponseSelector } from '@equinor/fusion-framework-module-http/selectors';
+import type { ExtractApiVersion } from './types';
+/**
+ * Extracts the correct API version from the provided `apiVersions` object based on the given `version` parameter.
+ *
+ * @param apiVersions - An object mapping API version strings to their corresponding versions.
+ * @param version - The version string to extract.
+ * @returns The extracted API version, or throws an error if the version is not supported.
+ */
+export declare const extractVersion: <TApiVersions extends Record<string, string>, TAllowedApiVersion extends string, TVersion extends string>(apiVersions: TApiVersions, version: TVersion) => ExtractApiVersion<TApiVersions, TVersion, TAllowedApiVersion>;
+/**
+ * Creates a response selector that parses the response body using the provided Zod schema.
+ *
+ * @param schema - The Zod schema to use for parsing the response body.
+ * @returns A response selector function that parses the response body using the provided schema.
+ */
+export declare const schemaSelector: <Output, Def extends z.ZodTypeDef, Input>(schema: z.ZodSchema<Output, Def, Input>) => ResponseSelector<Output>;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.1.5";
+export declare const version = "5.0.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-services",
-  "version": "4.1.5",
+  "version": "5.0.0",
   "description": "",
   "sideEffects": false,
   "main": "dist/esm/index.js",
@@ -50,6 +50,10 @@
       "import": "./dist/esm/index.js",
       "types": "./dist/types/index.d.ts"
     },
+    "./bookmarks": {
+      "import": "./dist/esm/bookmarks/index.js",
+      "types": "./dist/types/bookmarks/index.d.ts"
+    },
     "./context": {
       "import": "./dist/esm/context/index.js",
       "types": "./dist/types/context/index.d.ts"
@@ -66,10 +70,6 @@
       "import": "./dist/esm/context/related/index.js",
       "types": "./dist/types/context/related/index.d.ts"
     },
-    "./bookmarks": {
-      "import": "./dist/esm/bookmarks/index.js",
-      "types": "./dist/types/bookmarks/index.d.ts"
-    },
     "./notification": {
       "import": "./dist/esm/notification/index.js",
       "types": "./dist/types/notification/index.d.ts"
@@ -112,13 +112,14 @@
     "directory": "packages/modules/services"
   },
   "dependencies": {
-    "odata-query": "^7.0.4"
+    "odata-query": "^7.0.4",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "typescript": "^5.5.4",
     "@equinor/fusion-framework-module": "^4.3.5",
     "@equinor/fusion-framework-module-http": "^6.2.0",
-    "@equinor/fusion-framework-module-service-discovery": "^8.0.1"
+    "@equinor/fusion-framework-module-service-discovery": "^8.0.2"
   },
   "peerDependencies": {
     "odata-query": "^7.0.4",

package/src/bookmarks/README.md

@@ -0,0 +1,90 @@
+# Bookmarks API Module
+
+This module provides a set of services and utilities to manage user bookmarks. It allows for creating, reading, updating, and deleting bookmarks, ensuring that users can easily save and retrieve their favorite or frequently accessed items. The module is designed to be flexible and scalable, supporting various types of bookmarks and integrating seamlessly with other parts of the application.
+
+## Features
+- **Create Bookmarks**: Create new bookmarks with custom payloads.
+- **Retrieve Bookmarks**: Fetch individual bookmarks or all bookmarks.
+- **Update Bookmarks**: Update existing bookmarks with new data.
+- **Delete Bookmarks**: Remove bookmarks by their ID.
+- **Manage Favorites**: Add or remove bookmarks from the user's favorites.
+- **Bookmark Payloads**: Retrieve and manage bookmark payloads.
+
+## Usage
+
+### Creating a Bookmarks API Client
+To create an instance of the `BookmarksApiClient`, you need to provide an HTTP client and specify the method for API requests.
+
+
+```typescript
+import { BookmarksApiClient } from '@equinor/fusion-framework-module-services';
+import { HttpClient } from '@equinor/fusion-framework-module-http/client';
+
+// Create an instance of the HTTP client
+const httpClient = new HttpClient();
+
+// Create an instance of the BookmarksApiClient
+const bookmarksClient = new BookmarksApiClient(httpClient, 'json');
+```
+
+### Fetching All Bookmarks
+You can fetch all bookmarks using the `getAll` method.
+
+```typescript
+const allBookmarks = await bookmarksClient.getAll('v1');
+console.log(allBookmarks);
+```
+
+### Creating a Bookmark
+To create a new bookmark, use the `create` method.
+
+```typescript
+const newBookmark = await bookmarksClient.create('v1', {
+    name: 'My Bookmark',
+    description: 'A description for my bookmark',
+    isShared: true,
+    payload: { key: 'value' },
+});
+console.log(newBookmark);
+```
+
+### Updating a Bookmark
+To update an existing bookmark, use the `patch` method.
+
+```typescript
+const updatedBookmark = await bookmarksClient.patch('v1', {
+    bookmarkId: 'bookmark-id',
+    data: {
+        name: 'Updated Bookmark Name',
+        payload: { key: 'new value' },
+    }
+});
+console.log(updatedBookmark);
+```
+
+### Deleting a Bookmark
+To delete a bookmark by its ID, use the `delete` method.
+
+```typescript
+const deletedBookmarkId = await bookmarksClient.delete('v1', { bookmarkId: 'bookmark-id' });
+console.log(`Deleted bookmark with ID: ${deletedBookmarkId}`);
+```
+
+### Managing Bookmark Favorites
+You can add or remove bookmarks from the user's favorites.
+
+```typescript
+// Add to favorites
+await bookmarksClient.addFavourite('v1', { bookmarkId: 'bookmark-id' });
+
+// Remove from favorites
+await bookmarksClient.removeFavorite('v1', { bookmarkId: 'bookmark-id' });
+```
+
+### Fetching a Bookmark Payload
+To fetch the payload of a specific bookmark, use the `getPayload` method.
+
+```typescript
+const bookmarkPayload = await bookmarksClient.getPayload('v1', { bookmarkId: 'bookmark-id' });
+console.log(bookmarkPayload);
+```

package/src/bookmarks/api-version.ts

@@ -0,0 +1,4 @@
+export enum ApiVersion {
+    'v1' = '1.0',
+    'v2' = '2.0',
+}

package/src/bookmarks/client.ts

@@ -1,131 +1,311 @@
-import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod } from '../types';
 
-import { ClientMethod } from '..';
-import deleteBookmark from './delete/client';
-import { DeleteBookmarkResult, DeleteBookmarksFn, DeleteBookmarksResult } from './delete/types';
-import getBookmark from './get/client';
-import { ApiVersions, GetBookmarkResult, GetBookmarksFn, GetBookmarksResult } from './get/types';
-import { PostBookmarkResult, PostBookmarkFn, PostBookmarksResult } from './post/types';
-import postBookmark from './post/client';
-import patchBookmark, { PatchBookmarkFn, PatchBookmarkResult, PatchBookmarksResult } from './patch';
-import getAllBookmarks, { GetAllBookmarkResult, GetAllBookmarksResult } from './getAll';
-import addBookmarkFavorite, {
-    PostBookmarkFavoriteFn,
-    PostBookmarksFavoriteResult,
-} from './favorites/post';
-import deleteBookmarkFavorite, {
-    DeleteBookmarksFavoriteFn,
-    DeleteBookmarksFavoriteResult,
-} from './favorites/delete';
-import verifyBookmarkFavorite, {
-    HeadBookmarkFavoriteFn,
-    HeadBookmarksFavoriteResult,
-} from './favorites/head';
+import {
+    GetBookmarksArgs,
+    GetBookmarksResponse,
+    GetBookmarksResult,
+    GetBookmarksVersion,
+    getBookmarks,
+} from './endpoints/user-bookmarks.get';
 
+import {
+    GetBookmarkArg,
+    GetBookmarkResponse,
+    GetBookmarkResult,
+    GetBookmarkVersion,
+    getBookmark,
+} from './endpoints/bookmark.get';
+
+import {
+    CreateBookmarkArg,
+    CreateBookmarkResponse,
+    CreateBookmarkVersion,
+    CreateBookmarksResult,
+    createBookmark,
+} from './endpoints/bookmark.post';
+import {
+    type PatchBookmarkArg,
+    type PatchBookmarkResponse,
+    type PatchBookmarkVersion,
+    type PatchBookmarksResult,
+    patchBookmark,
+} from './endpoints/bookmark.patch';
+
+import {
+    BookmarkApplyArgs,
+    BookmarkApplyResponse,
+    BookmarkApplyResult,
+    BookmarkApplyVersion,
+    getBookmarkApply,
+} from './endpoints/bookmark-apply.get';
+import {
+    AddBookmarkFavouriteArgs,
+    AddBookmarkFavouriteResponse,
+    AddBookmarkFavouriteResult,
+    AddBookmarkFavouriteVersion,
+    addBookmarkAsFavourite,
+} from './endpoints/user-bookmark-favourite.post';
+import {
+    DeleteBookmarkArg,
+    DeleteBookmarkResponse,
+    DeleteBookmarkVersion,
+    deleteBookmark,
+} from './endpoints/bookmark.delete';
+import {
+    IsFavoriteBookmarkArgs,
+    IsFavoriteBookmarkResponse,
+    IsFavoriteBookmarkResult,
+    IsFavoriteBookmarkVersion,
+    isFavoriteBookmark,
+} from './endpoints/user-bookmark-favourite.head';
+import {
+    RemoveBookmarkFavouriteArgs,
+    RemoveBookmarkFavouriteResponse,
+    RemoveBookmarkFavouriteResult,
+    RemoveBookmarkFavouriteVersion,
+    removeFavoriteBookmark,
+} from './endpoints/user-bookmark-favourite.delete';
+
+/**
+ * Provides a client interface for interacting with the bookmarks API.
+ * This class abstracts the details of making API requests and handling responses.
+ * It provides methods for fetching, creating, updating, and deleting bookmarks,
+ * as well as managing bookmark favorites.
+ *
+ * @example
+ * ```typescript
+ * import { BookmarksApiClient } from '@equinor/fusion';
+ * import { HttpClient } from '@equinor/fusion-framework-module-http';
+ *
+ * const httpClient = new HttpClient({ baseUri: 'https://my-bookmarks-api.com/' });
+ *
+ * // create a bookmarks API client using a custom HTTP client
+ * const client = new BookmarksApiClient(httpClient, 'json');
+ *
+ * // fetch a bookmark by its ID
+ * const bookmark = await client.getBookmark('my-bookmark-id');
+ *
+ * // fetch all bookmarks for the current user
+ * const bookmarks = await client.query();
+ *
+ * // update a bookmark by its ID
+ * await client.patch({
+ *  bookmarkId: 'my-bookmark-id',
+ *  data: {
+ *     name: 'new-name'
+ *     payload: { foo: 'bar' }
+ *  }
+ * });
+ *
+ * // delete a bookmark by its ID
+ * await client.deleteBookmark('my-bookmark-id');
+ *
+ * // add or remove a bookmark to the current user's favorites
+ * await client.addFavorite({ bookmarkId:'my-bookmark-id' });
+ * await client.removeFavorite({ bookmarkId:'my-bookmark-id' });
+ * ```
+ *
+ * @template TMethod - The client method to use for the request, defaults to 'json'.
+ * @template TClient - The HTTP client to use for executing the request.
+ */
 export class BookmarksApiClient<
     TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
     TClient extends IHttpClient = IHttpClient,
-    TPayload = unknown,
 > {
+    /**
+     * Constructs a new instance of the BookmarksClient class.
+     *
+     * @param _client - The client instance to use for making API requests.
+     * @param _method - The client method to use for API requests.
+     */
     constructor(
         protected _client: TClient,
         protected _method: TMethod,
     ) {}
 
     /**
-     * Fetch bookmark by id
-     * @see {@link get/client}
+     * Fetch a single bookmark
+     *
+     * @template TVersion - The version of the API to call
+     * @template TResponse - The type of the result of the `getBookmark` function
+     * @param version - The API version to use
+     * @param args - Additional parameters to pass to the `getBookmark` function
+     * @returns The result of the `getBookmark` function
      */
-    public get<TVersion extends ApiVersions, TResult = GetBookmarkResult<TVersion, TPayload>>(
+    public get<TVersion extends GetBookmarkVersion, TResponse = GetBookmarkResponse<TVersion>>(
         version: TVersion,
-        ...args: Parameters<GetBookmarksFn<TVersion, TMethod, TClient, TPayload, TResult>>
-    ): GetBookmarksResult<TVersion, TMethod, TPayload, TResult> {
-        const fn = getBookmark(this._client, version, this._method);
-        return fn<TResult>(...args);
+        args: GetBookmarkArg<TVersion>,
+        init?: ClientRequestInit<TClient, TResponse>,
+    ): GetBookmarkResult<TVersion, TMethod, TResponse> {
+        const fn = getBookmark(version, this._client, this._method);
+        return fn(args, init);
     }
+
     /**
-     * Fetch all bookmarks
-     * @see {@link get/client}
+     * Retrieves the payload for a bookmark using the specified API version.
+     *
+     * @template TVersion - The version of the API to call.
+     * @template TResult - The type of the result of the `getBookmarkPayload` function.
+     * @param version - The API version to use for the bookmark payload.
+     * @param args - The arguments to pass to the `getBookmarkPayload` function.
+     * @returns The result of the `getBookmarkPayload` function.
      */
-    public getAll<TVersion extends ApiVersions, TResult = GetAllBookmarkResult<TVersion, TPayload>>(
+    public getPayload<
+        TVersion extends BookmarkApplyVersion,
+        TResponse = BookmarkApplyResponse<TVersion>,
+    >(
         version: TVersion,
-    ): GetAllBookmarksResult<TVersion, TMethod, TPayload, TResult> {
-        const fn = getAllBookmarks(this._client, version, this._method);
-        return fn<TResult>();
+        args: BookmarkApplyArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResponse>,
+    ): BookmarkApplyResult<TVersion, TMethod, TResponse> {
+        const fn = getBookmarkApply(version, this._client, this._method);
+        return fn(args, init);
     }
 
     /**
-     * Create a new bookmark
-     * @see {@link get/client}
+     * Query a person's bookmarks.
+     *
+     * @template TVersion - The version of the API to call.
+     * @template TResponse - The type of the result of the `getBookmarks` function.
+     * @param version - The API version to use.
+     * @param args - Additional arguments to pass to the `getBookmarks` function.
+     * @param init - Optional request initialization options.
+     * @returns The result of calling the `getBookmarks` function.
      */
-    public post<TVersion extends ApiVersions, TResult = PostBookmarkResult<TVersion, TPayload>>(
+    public query<TVersion extends GetBookmarksVersion, TResponse = GetBookmarksResponse<TVersion>>(
         version: TVersion,
-        ...args: Parameters<PostBookmarkFn<TVersion, TMethod, TClient, TPayload, TResult>>
-    ): PostBookmarksResult<TVersion, TMethod, TPayload, TResult> {
-        const fn = postBookmark(this._client, version, this._method);
-        return fn<TResult>(...args);
+        args?: GetBookmarksArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResponse>,
+    ): GetBookmarksResult<TVersion, TMethod, TResponse> {
+        const fn = getBookmarks(version, this._client, this._method);
+        return fn(args, init);
     }
 
     /**
      * Update a bookmark
-     * @see {@link get/client}
+     *
+     * @template TVersion - The version of the API to call
+     * @template TResponse - The type of the result of the `patchBookmark` function
+     * @param version - The API version to use
+     * @param args - The parameters to pass to the `patchBookmark` function
+     * @returns The result of the `patchBookmark` function
+     */
+    public patch<
+        TVersion extends PatchBookmarkVersion,
+        TResponse = PatchBookmarkResponse<TVersion>,
+    >(
+        version: TVersion,
+        args: PatchBookmarkArg<TVersion>,
+        init?: ClientRequestInit<TClient, TResponse>,
+    ): PatchBookmarksResult<TVersion, TMethod, TResponse> {
+        const fn = patchBookmark(version, this._client, this._method);
+        return fn(args, init);
+    }
+
+    /**
+     * Create a new bookmark
+     *
+     * @template TVersion - The version of the API to call
+     * @template TResult - The type of the result of the `postBookmark` function
+     * @param version - The API version to use
+     * @param request - The parameters to pass to the `postBookmark` function
+     * @returns The result of creating the bookmark
      */
-    public patch<TVersion extends ApiVersions, TResult = PatchBookmarkResult<TVersion, TPayload>>(
+    public create<
+        TVersion extends CreateBookmarkVersion,
+        TResponse = CreateBookmarkResponse<TVersion>,
+    >(
         version: TVersion,
-        ...args: Parameters<PatchBookmarkFn<TVersion, TMethod, TClient, TPayload, TResult>>
-    ): PatchBookmarksResult<TVersion, TMethod, TPayload, TResult> {
-        const fn = patchBookmark(this._client, version, this._method);
-        return fn<TResult>(...args);
+        request: CreateBookmarkArg<TVersion>,
+        init?: ClientRequestInit<TClient, TResponse>,
+    ): CreateBookmarksResult<TVersion, TMethod, TResponse> {
+        const fn = createBookmark(version, this._client, this._method);
+        return fn(request, init);
     }
 
     /**
-     * Delete a bookmark
-     * @see {@link delete/client}
+     * Deletes a bookmark.
+     *
+     * @template TVersion - The version of the API to call.
+     * @template TResponse - The type of the result of the `deleteBookmark` function.
+     * @param version - The version of the delete bookmark API to use.
+     * @param args - The arguments to pass to the `deleteBookmark` function.
+     * @returns The result of the delete bookmark operation.
      */
-    public delete<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(
+    public delete<
+        TVersion extends DeleteBookmarkVersion,
+        TResponse = DeleteBookmarkResponse<TVersion>,
+    >(
         version: TVersion,
-        ...args: Parameters<DeleteBookmarksFn<TVersion, TMethod, TClient, TResult>>
-    ): DeleteBookmarksResult<TVersion, TMethod, TResult> {
-        const fn = deleteBookmark(this._client, version, this._method);
-        return fn<TResult>(...args);
+        args: DeleteBookmarkArg<TVersion>,
+        init?: ClientRequestInit<TClient, TResponse>,
+    ): GetBookmarkResult<TVersion, TMethod, TResponse> {
+        const fn = deleteBookmark(version, this._client, this._method);
+        return fn(args, init);
     }
 
     /**
-     * Add bookmark to favorites by bookmark id
-     * @see {@link addFavorite/client}
+     * Check if a bookmark is a favorite.
+     *
+     * @template TVersion - The version of the API to call.
+     * @template TResult - The type of the result of the `verifyBookmarkFavorite` function.
+     * @param version - The API version to use.
+     * @param args - The arguments to pass to the `HeadBookmarkFavoriteFn` function.
+     * @returns The result of the `HeadBookmarksFavoriteResult` function.
      */
-    public addFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(
+    public isFavorite<
+        TVersion extends IsFavoriteBookmarkVersion,
+        TResponse = IsFavoriteBookmarkResponse<TVersion>,
+    >(
         version: TVersion,
-        ...args: Parameters<PostBookmarkFavoriteFn<TVersion, TMethod, TClient, TResult>>
-    ): PostBookmarksFavoriteResult<TVersion, TMethod, TResult> {
-        const fn = addBookmarkFavorite(this._client, version, this._method);
-        return fn<TResult>(...args);
+        args: IsFavoriteBookmarkArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResponse>,
+    ): IsFavoriteBookmarkResult<TVersion, TMethod, TResponse> {
+        const fn = isFavoriteBookmark(version, this._client, this._method);
+        return fn(args, init);
     }
 
     /**
+     * Add the provided bookmark to the user's favorites.
      *
-     * Remove bookmark from favorites by bookmark id
-     * @see {@link removeFavorite/client}
+     * @template TVersion - The version of the API to call.
+     * @template TResponse - The type of the result of the `addBookmarkFavorite` function.
+     * @param version - The API version to use.
+     * @param args - The parameters to pass to the `PostBookmarkFavoriteFn` function.
+     * @returns The result of adding the bookmark to the user's favorites.
      */
-    public removeFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(
+    public addFavourite<
+        TVersion extends AddBookmarkFavouriteVersion,
+        TResponse = AddBookmarkFavouriteResponse<TVersion>,
+    >(
         version: TVersion,
-        ...args: Parameters<DeleteBookmarksFavoriteFn<TVersion, TMethod, TClient, TResult>>
-    ): DeleteBookmarksFavoriteResult<TVersion, TMethod, TResult> {
-        const fn = deleteBookmarkFavorite(this._client, version, this._method);
-        return fn<TResult>(...args);
+        args: AddBookmarkFavouriteArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResponse>,
+    ): AddBookmarkFavouriteResult<TVersion, TMethod, TResponse> {
+        const fn = addBookmarkAsFavourite(version, this._client, this._method);
+        return fn(args, init);
     }
 
     /**
+     * Removes the provided bookmark from the user's collection of bookmarks.
      *
-     * Verify that the current bookmark is present in the users collection of bookmarks.
-     * @see {@link verifyFavorite/client}
+     * @template TVersion - The version of the API to call.
+     * @template TResult - The type of the result of the `deleteBookmarkFavorite` function.
+     * @param version - The API version to use for the request.
+     * @param request - The parameters to pass to the `deleteBookmarkFavorite` function.
+     * @returns The result of the `deleteBookmarkFavorite` function.
      */
-    public verifyFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(
+    public removeFavourite<
+        TVersion extends RemoveBookmarkFavouriteVersion,
+        TResponse = RemoveBookmarkFavouriteResponse<TVersion>,
+    >(
         version: TVersion,
-        ...args: Parameters<HeadBookmarkFavoriteFn<TVersion, TMethod, TClient, TResult>>
-    ): HeadBookmarksFavoriteResult<TVersion, TMethod, TResult> {
-        const fn = verifyBookmarkFavorite(this._client, version, this._method);
-        return fn<TResult>(...args);
+        request: RemoveBookmarkFavouriteArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResponse>,
+    ): RemoveBookmarkFavouriteResult<TVersion, TMethod, TResponse> {
+        const fn = removeFavoriteBookmark(version, this._client, this._method);
+        return fn(request, init);
     }
 }