@equinor/fusion-framework-module-services 2.2.0 → 2.3.1

package/dist/types/bookmarks/client.d.ts

@@ -3,8 +3,11 @@ import { ClientMethod } from '@equinor/fusion-framework-module-services/context'
 import { DeleteBookmarkResult, DeleteBookmarksFn, DeleteBookmarksResult } from './delete/types';
 import { ApiVersions, GetBookmarkResult, GetBookmarksFn, GetBookmarksResult } from './get/types';
 import { PostBookmarkResult, PostBookmarkFn, PostBookmarksResult } from './post/types';
-import { PutBookmarkFn as PatchBookmarkFn, PutBookmarkResult as PatchBookmarkResult, PutBookmarksResult as PatchBookmarksResult } from './patch';
+import { PatchBookmarkFn, PatchBookmarkResult, PatchBookmarksResult } from './patch';
 import { GetAllBookmarkResult, GetAllBookmarksResult } from './getAll';
+import { PostBookmarkFavoriteFn, PostBookmarksFavoriteResult } from './favorites/post';
+import { DeleteBookmarksFavoriteFn, DeleteBookmarksFavoriteResult } from './favorites/delete';
+import { HeadBookmarkFavoriteFn, HeadBookmarksFavoriteResult } from './favorites/head';
 export declare class BookmarksApiClient<TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TPayload = unknown> {
     protected _client: TClient;
     protected _method: TMethod;
@@ -14,5 +17,8 @@ export declare class BookmarksApiClient<TMethod extends keyof ClientMethod<unkno
     post<TVersion extends ApiVersions, TResult = PostBookmarkResult<TVersion, TPayload>>(version: TVersion, ...args: Parameters<PostBookmarkFn<TVersion, TMethod, TClient, TPayload, TResult>>): PostBookmarksResult<TVersion, TMethod, TPayload, TResult>;
     patch<TVersion extends ApiVersions, TResult = PatchBookmarkResult<TVersion, TPayload>>(version: TVersion, ...args: Parameters<PatchBookmarkFn<TVersion, TMethod, TClient, TPayload, TResult>>): PatchBookmarksResult<TVersion, TMethod, TPayload, TResult>;
     delete<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(version: TVersion, ...args: Parameters<DeleteBookmarksFn<TVersion, TMethod, TClient, TResult>>): DeleteBookmarksResult<TVersion, TMethod, TResult>;
+    addFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(version: TVersion, ...args: Parameters<PostBookmarkFavoriteFn<TVersion, TMethod, TClient, TResult>>): PostBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+    removeFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(version: TVersion, ...args: Parameters<DeleteBookmarksFavoriteFn<TVersion, TMethod, TClient, TResult>>): DeleteBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+    verifyFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(version: TVersion, ...args: Parameters<HeadBookmarkFavoriteFn<TVersion, TMethod, TClient, TResult>>): HeadBookmarksFavoriteResult<TVersion, TMethod, TResult>;
 }
 export default BookmarksApiClient;

package/dist/types/bookmarks/favorites/delete/client.d.ts

@@ -0,0 +1,5 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { DeleteBookmarkFavoriteArgs, DeleteBookmarkFavoriteResult, DeleteBookmarksFavoriteResult } from './types';
+export declare const deleteBookmarkFavorite: <TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = DeleteBookmarkFavoriteResult<TVersion>>(args: DeleteBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => DeleteBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+export default deleteBookmarkFavorite;

package/dist/types/bookmarks/favorites/delete/generate-endpoint.d.ts

@@ -0,0 +1,2 @@
+import { DeleteBookmarkFavoriteArgs } from './types';
+export declare const generateEndpoint: <TVersion extends "v1">(version: TVersion, args: DeleteBookmarkFavoriteArgs<TVersion>) => string;

package/dist/types/bookmarks/favorites/delete/generate-parameters.d.ts

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiClientArguments } from '../..';
+import { DeleteBookmarkFavoriteArgs } from './types';
+export declare const generateParameters: <TResult, TVersion extends "v1", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: DeleteBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;

package/dist/types/bookmarks/favorites/delete/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export { deleteBookmarkFavorite as deleteBookmark, default } from './client';
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';

package/dist/types/bookmarks/favorites/delete/types-v1.d.ts

@@ -0,0 +1,3 @@
+export type DeleteBookmarksFavoriteArgsV1 = {
+    bookmarkId: string;
+};

package/dist/types/bookmarks/favorites/delete/types.d.ts

@@ -0,0 +1,15 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { DeleteBookmarksFavoriteArgsV1 } from './types-v1';
+export type DeleteBookmarkFavoriteResult<TVersion extends ApiVersions> = DeleteBookmarksFavoriteVersions[TVersion]['result'];
+export type DeleteBookmarkFavoriteArgs<TVersion extends ApiVersions> = DeleteBookmarksFavoriteVersions[TVersion]['args'];
+export type DeleteBookmarksFavoriteResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = DeleteBookmarkFavoriteResult<TVersion>> = ClientMethod<TResult>[TMethod];
+export type DeleteBookmarksFavoriteFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = DeleteBookmarkFavoriteResult<TVersion>> = (args: DeleteBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => DeleteBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+export type DeleteBookmarksFavoriteVersions = {
+    ['v1']: {
+        args: DeleteBookmarksFavoriteArgsV1;
+        result: undefined;
+    };
+};
+export type ApiVersions = keyof DeleteBookmarksFavoriteVersions;

package/dist/types/bookmarks/favorites/head/client.d.ts

@@ -0,0 +1,5 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { HeadBookmarkFavoriteArgs, HeadBookmarkFavoriteResult, HeadBookmarksFavoriteResult } from './types';
+export declare const verifyBookmarkFavorite: <TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = HeadBookmarkFavoriteResult<TVersion>>(args: HeadBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => HeadBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+export default verifyBookmarkFavorite;

package/dist/types/bookmarks/favorites/head/generate-endpoint.d.ts

@@ -0,0 +1,2 @@
+import { HeadBookmarkFavoriteArgs } from './types';
+export declare const generateEndpoint: <TVersion extends "v1">(version: TVersion, args: HeadBookmarkFavoriteArgs<TVersion>) => string;

package/dist/types/bookmarks/favorites/head/generate-parameters.d.ts

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiClientArguments } from '../..';
+import { HeadBookmarkFavoriteArgs } from './types';
+export declare const generateParameters: <TResult, TVersion extends "v1", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: HeadBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;

package/dist/types/bookmarks/favorites/head/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export { verifyBookmarkFavorite, default } from './client';
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';

package/dist/types/bookmarks/favorites/head/types.d.ts

@@ -0,0 +1,17 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+export type HeadBookmarkFavoriteResult<TVersion extends ApiVersions> = HeadBookmarksFavoriteVersions[TVersion]['result'];
+export type HeadBookmarkFavoriteArgs<TVersion extends ApiVersions> = HeadBookmarksFavoriteVersions[TVersion]['args'];
+export type HeadBookmarksFavoriteResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = HeadBookmarkFavoriteResult<TVersion>> = ClientMethod<TResult>[TMethod];
+export type HeadBookmarkFavoriteFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = HeadBookmarkFavoriteResult<TVersion>> = (args: HeadBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => HeadBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+export interface HeadBookmarksFavoriteArgsV1 {
+    bookmarkId: string;
+}
+export type HeadBookmarksFavoriteVersions = {
+    ['v1']: {
+        args: HeadBookmarksFavoriteArgsV1;
+        result: Response;
+    };
+};
+export type ApiVersions = keyof HeadBookmarksFavoriteVersions;

package/dist/types/bookmarks/favorites/post/client.d.ts

@@ -0,0 +1,5 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { PostBookmarkFavoriteArgs, PostBookmarkFavoriteResult, PostBookmarksFavoriteResult } from './types';
+export declare const addBookmarkFavorite: <TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PostBookmarkFavoriteResult<TVersion>>(args: PostBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => PostBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+export default addBookmarkFavorite;

package/dist/types/bookmarks/favorites/post/generate-endpoint.d.ts

@@ -0,0 +1,2 @@
+import { PostBookmarkFavoriteArgs } from './types';
+export declare const generateEndpoint: <TVersion extends "v1">(version: TVersion, _args: PostBookmarkFavoriteArgs<TVersion>) => string;

package/dist/types/bookmarks/favorites/post/generate-parameters.d.ts

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiClientArguments } from '../..';
+import { PostBookmarkFavoriteArgs } from './types';
+export declare const generateParameters: <TResult, TVersion extends "v1", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PostBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;

package/dist/types/bookmarks/favorites/post/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export { addBookmarkFavorite, default } from './client';
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';

package/dist/types/bookmarks/favorites/post/types.d.ts

@@ -0,0 +1,17 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+export type PostBookmarkFavoriteResult<TVersion extends ApiVersions> = PostBookmarksFavoriteVersions[TVersion]['result'];
+export type PostBookmarkFavoriteArgs<TVersion extends ApiVersions> = PostBookmarksFavoriteVersions[TVersion]['args'];
+export type PostBookmarksFavoriteResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = PostBookmarkFavoriteResult<TVersion>> = ClientMethod<TResult>[TMethod];
+export type PostBookmarkFavoriteFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = PostBookmarkFavoriteResult<TVersion>> = (args: PostBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PostBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+export interface PostBookmarksFavoriteArgsV1 {
+    bookmarkId: string;
+}
+export type PostBookmarksFavoriteVersions = {
+    ['v1']: {
+        args: PostBookmarksFavoriteArgsV1;
+        result: Response;
+    };
+};
+export type ApiVersions = keyof PostBookmarksFavoriteVersions;

package/dist/types/bookmarks/patch/client.d.ts

@@ -1,5 +1,5 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
-import { PutBookmarkArgs, PutBookmarkResult, PutBookmarksResult } from './types';
-export declare const putBookmark: <TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PutBookmarkResult<TVersion, unknown>>(args: PutBookmarkArgs<TVersion, unknown>, init?: ClientRequestInit<TClient, TResult> | undefined) => PutBookmarksResult<TVersion, TMethod, unknown, TResult>;
-export default putBookmark;
+import { PatchBookmarkArgs, PatchBookmarkResult, PatchBookmarksResult } from './types';
+export declare const patchBookmark: <TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PatchBookmarkResult<TVersion, unknown>>(args: PatchBookmarkArgs<TVersion, unknown>, init?: ClientRequestInit<TClient, TResult> | undefined) => PatchBookmarksResult<TVersion, TMethod, unknown, TResult>;
+export default patchBookmark;

package/dist/types/bookmarks/patch/generate-endpoint.d.ts

@@ -1,2 +1,2 @@
-import { PutBookmarkArgs } from './types';
-export declare const generateEndpoint: <TVersion extends "v1">(version: TVersion, _args: PutBookmarkArgs<TVersion, unknown>) => string;
+import { PatchBookmarkArgs } from './types';
+export declare const generateEndpoint: <TVersion extends "v1">(version: TVersion, _args: PatchBookmarkArgs<TVersion, unknown>) => string;

package/dist/types/bookmarks/patch/generate-parameters.d.ts

@@ -1,4 +1,4 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ApiClientArguments } from '../..';
-import { PutBookmarkArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends "v1", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PutBookmarkArgs<TVersion, unknown>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;
+import { PatchBookmarkArgs } from './types';
+export declare const generateParameters: <TResult, TVersion extends "v1", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PatchBookmarkArgs<TVersion, unknown>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;

package/dist/types/bookmarks/patch/index.d.ts

@@ -1,4 +1,4 @@
 export * from './types';
-export { putBookmark, default } from './client';
-export { generateEndpoint as generatePutEndpoint } from './generate-endpoint';
-export { generateParameters as generatePutParameters } from './generate-parameters';
+export { patchBookmark, default } from './client';
+export { generateEndpoint as generatePatchEndpoint } from './generate-endpoint';
+export { generateParameters as generatePatchParameters } from './generate-parameters';

package/dist/types/bookmarks/patch/types.d.ts

@@ -3,17 +3,17 @@ import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client'
 import { ClientMethod } from '../..';
 import { ApiBookmarkEntityV1 } from '../api-models';
 import { PostBookmarksArgsV1 } from '../post';
-export type PutBookmarkResult<TVersion extends ApiVersions, TPayload> = PutBookmarksVersions<TPayload>[TVersion]['result'];
-export type PutBookmarkArgs<TVersion extends ApiVersions, TPayload = unknown> = PutBookmarksVersions<TPayload>[TVersion]['args'];
-export type PutBookmarksResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TPayload = unknown, TResult = PutBookmarkResult<TVersion, TPayload>> = ClientMethod<TResult>[TMethod];
-export type PutBookmarkFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TPayload = unknown, TResult = PutBookmarkResult<TVersion, TPayload>> = (args: PutBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PutBookmarksResult<TVersion, TMethod, TPayload, TResult>;
-export interface PutBookmarksArgsV1<T = unknown> extends PostBookmarksArgsV1<T> {
+export type PatchBookmarkResult<TVersion extends ApiVersions, TPayload> = PatchBookmarksVersions<TPayload>[TVersion]['result'];
+export type PatchBookmarkArgs<TVersion extends ApiVersions, TPayload = unknown> = PatchBookmarksVersions<TPayload>[TVersion]['args'];
+export type PatchBookmarksResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TPayload = unknown, TResult = PatchBookmarkResult<TVersion, TPayload>> = ClientMethod<TResult>[TMethod];
+export type PatchBookmarkFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TPayload = unknown, TResult = PatchBookmarkResult<TVersion, TPayload>> = (args: PatchBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PatchBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+export interface PatchBookmarksArgsV1<T = unknown> extends Partial<PostBookmarksArgsV1<T>> {
     id: string;
 }
-export type PutBookmarksVersions<TPayload = unknown> = {
+export type PatchBookmarksVersions<TPayload = unknown> = {
     ['v1']: {
-        args: PutBookmarksArgsV1<TPayload>;
+        args: PatchBookmarksArgsV1<TPayload>;
         result: ApiBookmarkEntityV1<TPayload>;
     };
 };
-export type ApiVersions = keyof PutBookmarksVersions<unknown>;
+export type ApiVersions = keyof PatchBookmarksVersions<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@equinor/fusion-framework-module-services",
-    "version": "2.2.0",
+    "version": "2.3.1",
     "description": "",
     "sideEffects": false,
     "main": "dist/esm/index.js",
@@ -63,5 +63,5 @@
         "@equinor/fusion-framework-module": ">=1.2.2",
         "odata-query": "^7.0.3"
     },
-    "gitHead": "8271bcdf843d09c67cb60a563cf32dbd9767e621"
+    "gitHead": "1dd3688d5ac207281d512fcb88fdb9409ad62748"
 }

package/src/bookmarks/client.ts

@@ -7,12 +7,20 @@ 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, {
-    PutBookmarkFn as PatchBookmarkFn,
-    PutBookmarkResult as PatchBookmarkResult,
-    PutBookmarksResult as PatchBookmarksResult,
-} from './patch';
+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';
 
 export class BookmarksApiClient<
     TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
@@ -67,6 +75,10 @@ export class BookmarksApiClient<
         return fn<TResult>(...args);
     }
 
+    /**
+     * Delete a bookmark
+     * @see {@link delete/client}
+     */
     public delete<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(
         version: TVersion,
         ...args: Parameters<DeleteBookmarksFn<TVersion, TMethod, TClient, TResult>>
@@ -74,6 +86,44 @@ export class BookmarksApiClient<
         const fn = deleteBookmark(this._client, version, this._method);
         return fn<TResult>(...args);
     }
+
+    /**
+     * Add bookmark to favorites by bookmark id
+     * @see {@link addFavorite/client}
+     */
+    public addFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<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);
+    }
+
+    /**
+     *
+     * Remove bookmark from favorites by bookmark id
+     * @see {@link removeFavorite/client}
+     */
+    public removeFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<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);
+    }
+
+    /**
+     *
+     * Verify that the current bookmark is present in the users collection of bookmarks.
+     * @see {@link verifyFavorite/client}
+     */
+    public verifyFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<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);
+    }
 }
 
 export default BookmarksApiClient;

package/src/bookmarks/favorites/delete/client.ts

@@ -0,0 +1,35 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { generateParameters } from './generate-parameters';
+import {
+    ApiVersions,
+    DeleteBookmarkFavoriteArgs,
+    DeleteBookmarkFavoriteResult,
+    DeleteBookmarksFavoriteResult,
+} from './types';
+
+/**
+ * Method for fetching bookmark by it`s id from bookmark service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const deleteBookmarkFavorite =
+    <
+        TVersion extends ApiVersions = ApiVersions,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'fetch' as TMethod
+    ) =>
+    <TResult = DeleteBookmarkFavoriteResult<TVersion>>(
+        args: DeleteBookmarkFavoriteArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResult>
+    ): DeleteBookmarksFavoriteResult<TVersion, TMethod, TResult> =>
+        client[method](
+            ...generateParameters<TResult, TVersion, TClient>(version, args, init)
+        ) as DeleteBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+
+export default deleteBookmarkFavorite;

package/src/bookmarks/favorites/delete/generate-endpoint.ts

@@ -0,0 +1,19 @@
+import { ApiVersions, DeleteBookmarkFavoriteArgs } from './types';
+
+/**
+ * Method for generating endpoint for deleting a bookmark.
+ */
+export const generateEndpoint = <TVersion extends ApiVersions>(
+    version: TVersion,
+    args: DeleteBookmarkFavoriteArgs<TVersion>
+) => {
+    switch (version) {
+        case 'v1':
+        default: {
+            const { bookmarkId } = args as { bookmarkId: string };
+            const params = new URLSearchParams();
+            params.append('api-version', '1.0');
+            return `/persons/me/bookmarks/favorites/${bookmarkId}/?${String(params)}`;
+        }
+    }
+};

package/src/bookmarks/favorites/delete/generate-parameters.ts

@@ -0,0 +1,25 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiClientArguments } from '../..';
+import { generateEndpoint } from './generate-endpoint';
+import { ApiVersions, DeleteBookmarkFavoriteArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends ApiVersions,
+    TClient extends IHttpClient = IHttpClient
+>(
+    version: TVersion,
+    args: DeleteBookmarkFavoriteArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+
+    const requestParams: ClientRequestInit<TClient, TResult> = Object.assign(
+        {},
+        { method: 'Delete' },
+        init
+    );
+
+    return [path, requestParams];
+};

package/src/bookmarks/favorites/delete/index.ts

@@ -0,0 +1,6 @@
+export * from './types';
+
+export { deleteBookmarkFavorite as deleteBookmark, default } from './client';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';

package/src/bookmarks/favorites/delete/types-v1.ts

@@ -0,0 +1,2 @@
+/** arguments for v1 delete bookmark favorite */
+export type DeleteBookmarksFavoriteArgsV1 = { bookmarkId: string };

package/src/bookmarks/favorites/delete/types.ts

@@ -0,0 +1,33 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { DeleteBookmarksFavoriteArgsV1 } from './types-v1';
+
+export type DeleteBookmarkFavoriteResult<TVersion extends ApiVersions> =
+    DeleteBookmarksFavoriteVersions[TVersion]['result'];
+
+export type DeleteBookmarkFavoriteArgs<TVersion extends ApiVersions> =
+    DeleteBookmarksFavoriteVersions[TVersion]['args'];
+
+export type DeleteBookmarksFavoriteResult<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = DeleteBookmarkFavoriteResult<TVersion>
+> = ClientMethod<TResult>[TMethod];
+
+export type DeleteBookmarksFavoriteFn<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = DeleteBookmarkFavoriteResult<TVersion>
+> = (
+    args: DeleteBookmarkFavoriteArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+) => DeleteBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+
+export type DeleteBookmarksFavoriteVersions = {
+    ['v1']: { args: DeleteBookmarksFavoriteArgsV1; result: undefined };
+};
+
+/**Api versions for bookmarks service */
+export type ApiVersions = keyof DeleteBookmarksFavoriteVersions;

package/src/bookmarks/favorites/head/client.ts

@@ -0,0 +1,35 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { generateParameters } from './generate-parameters';
+import {
+    ApiVersions,
+    HeadBookmarkFavoriteArgs,
+    HeadBookmarkFavoriteResult,
+    HeadBookmarksFavoriteResult,
+} from './types';
+
+/**
+ * Verify that the bookmark is owned by the current user.
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const verifyBookmarkFavorite =
+    <
+        TVersion extends ApiVersions = ApiVersions,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod
+    ) =>
+    <TResult = HeadBookmarkFavoriteResult<TVersion>>(
+        args: HeadBookmarkFavoriteArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResult>
+    ): HeadBookmarksFavoriteResult<TVersion, TMethod, TResult> =>
+        client[method](
+            ...generateParameters<TResult, TVersion, TClient>(version, args, init)
+        ) as HeadBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+
+export default verifyBookmarkFavorite;

package/src/bookmarks/favorites/head/generate-endpoint.ts

@@ -0,0 +1,19 @@
+import { ApiVersions, HeadBookmarkFavoriteArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting bookmark by id
+ */
+export const generateEndpoint = <TVersion extends ApiVersions>(
+    version: TVersion,
+    args: HeadBookmarkFavoriteArgs<TVersion>
+) => {
+    switch (version) {
+        case 'v1':
+        default: {
+            const { bookmarkId } = args as { bookmarkId: string };
+            const params = new URLSearchParams();
+            params.append('api-version', version);
+            return `/persons/me/bookmarks/favorites/${bookmarkId}?${String(params)}`;
+        }
+    }
+};

package/src/bookmarks/favorites/head/generate-parameters.ts

@@ -0,0 +1,28 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiClientArguments } from '../..';
+import { generateEndpoint } from './generate-endpoint';
+import { ApiVersions, HeadBookmarkFavoriteArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends ApiVersions,
+    TClient extends IHttpClient = IHttpClient
+>(
+    version: TVersion,
+    args: HeadBookmarkFavoriteArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+
+    const headers = new Headers();
+    headers.append('content-type', 'application/json');
+
+    const requestParams: ClientRequestInit<TClient, TResult> = Object.assign(
+        {},
+        { method: 'head', headers: headers },
+        init
+    );
+
+    return [path, requestParams];
+};

package/src/bookmarks/favorites/head/index.ts

@@ -0,0 +1,6 @@
+export * from './types';
+
+export { verifyBookmarkFavorite, default } from './client';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';

package/src/bookmarks/favorites/head/types.ts

@@ -0,0 +1,35 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+
+export type HeadBookmarkFavoriteResult<TVersion extends ApiVersions> =
+    HeadBookmarksFavoriteVersions[TVersion]['result'];
+
+export type HeadBookmarkFavoriteArgs<TVersion extends ApiVersions> =
+    HeadBookmarksFavoriteVersions[TVersion]['args'];
+
+export type HeadBookmarksFavoriteResult<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = HeadBookmarkFavoriteResult<TVersion>
+> = ClientMethod<TResult>[TMethod];
+
+export type HeadBookmarkFavoriteFn<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = HeadBookmarkFavoriteResult<TVersion>
+> = (
+    args: HeadBookmarkFavoriteArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+) => HeadBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+
+export interface HeadBookmarksFavoriteArgsV1 {
+    bookmarkId: string;
+}
+
+export type HeadBookmarksFavoriteVersions = {
+    ['v1']: { args: HeadBookmarksFavoriteArgsV1; result: Response };
+};
+
+export type ApiVersions = keyof HeadBookmarksFavoriteVersions;

package/src/bookmarks/favorites/post/client.ts

@@ -0,0 +1,35 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { generateParameters } from './generate-parameters';
+import {
+    ApiVersions,
+    PostBookmarkFavoriteArgs,
+    PostBookmarkFavoriteResult,
+    PostBookmarksFavoriteResult,
+} from './types';
+
+/**
+ * Method for adding other users bookmark to your favorites.
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const addBookmarkFavorite =
+    <
+        TVersion extends ApiVersions = ApiVersions,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod
+    ) =>
+    <TResult = PostBookmarkFavoriteResult<TVersion>>(
+        args: PostBookmarkFavoriteArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResult>
+    ): PostBookmarksFavoriteResult<TVersion, TMethod, TResult> =>
+        client[method](
+            ...generateParameters<TResult, TVersion, TClient>(version, args, init)
+        ) as PostBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+
+export default addBookmarkFavorite;