@equinor/fusion-framework-module-services 0.0.0-next-20230915111233

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/favourites/${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;

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

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

package/src/bookmarks/favorites/post/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, PostBookmarkFavoriteArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends ApiVersions,
+    TClient extends IHttpClient = IHttpClient,
+>(
+    version: TVersion,
+    args: PostBookmarkFavoriteArgs<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: 'post', body: JSON.stringify(args), headers: headers },
+        init,
+    );
+
+    return [path, requestParams];
+};

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

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

package/src/bookmarks/favorites/post/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 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/src/bookmarks/get/client.ts

@@ -0,0 +1,30 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { generateParameters } from './generate-parameters';
+import { ApiVersions, GetBookmarkArgs, GetBookmarkResult, GetBookmarksResult } 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 getBookmark =
+    <
+        TVersion extends ApiVersions = ApiVersions,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient,
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod,
+    ) =>
+    <TResult = GetBookmarkResult<TVersion, unknown>>(
+        args: GetBookmarkArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResult>,
+    ): GetBookmarksResult<TVersion, TMethod, unknown, TResult> =>
+        client[method](
+            ...generateParameters<TResult, TVersion, TClient>(version, args, init),
+        ) as GetBookmarksResult<TVersion, TMethod, unknown, TResult>;
+
+export default getBookmark;

package/src/bookmarks/get/generate-endpoint.ts

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

package/src/bookmarks/get/generate-parameters.ts

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

package/src/bookmarks/get/index.ts

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

package/src/bookmarks/get/types.ts

@@ -0,0 +1,39 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { ApiBookmarkEntityV1 } from '../api-models';
+
+export type GetBookmarkResult<
+    TVersion extends ApiVersions,
+    TPayload,
+> = GetBookmarksVersions<TPayload>[TVersion]['result'];
+
+/** Returns args for GetBookmark based on version*/
+export type GetBookmarkArgs<TVersion extends ApiVersions> = GetBookmarksVersions[TVersion]['args'];
+
+/**Gets result type for GetBookmark call based on version and method */
+export type GetBookmarksResult<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TPayload = unknown,
+    TResult = GetBookmarkResult<TVersion, TPayload>,
+> = ClientMethod<TResult>[TMethod];
+
+export type GetBookmarksFn<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TPayload = unknown,
+    TResult = GetBookmarkResult<TVersion, TPayload>,
+> = (
+    args: GetBookmarkArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+) => GetBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+
+type GetBookmarksArgsV1 = { id: string };
+
+export type GetBookmarksVersions<TPayload = unknown> = {
+    ['v1']: { args: GetBookmarksArgsV1; result: ApiBookmarkEntityV1<TPayload> };
+};
+
+export type ApiVersions = keyof GetBookmarksVersions<unknown>;

package/src/bookmarks/getAll/client.ts

@@ -0,0 +1,30 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+
+import { generateParameters } from './generate-parameters';
+import { ApiVersions, GetAllBookmarkResult, GetAllBookmarksResult } from './types';
+
+/**
+ * Method for fetching all bookmarks for the current user 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 getAllBookmarks =
+    <
+        TVersion extends ApiVersions = ApiVersions,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient,
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod,
+    ) =>
+    <TResult = GetAllBookmarkResult<TVersion, unknown>>(
+        init?: ClientRequestInit<TClient, TResult>,
+    ): GetAllBookmarksResult<TVersion, TMethod, unknown, TResult> =>
+        client[method](
+            ...generateParameters<TResult, TVersion, TClient>(version, init),
+        ) as GetAllBookmarksResult<TVersion, TMethod, unknown, TResult>;
+
+export default getAllBookmarks;

package/src/bookmarks/getAll/generate-endpoint.ts

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

package/src/bookmarks/getAll/generate-parameters.ts

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

package/src/bookmarks/getAll/index.ts

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

package/src/bookmarks/getAll/types.ts

@@ -0,0 +1,21 @@
+import { ApiBookmarkEntityV1 } from '../api-models';
+import { ClientMethod } from '../types';
+
+/**Gets result type for GetAllBookmark call based on version and method */
+export type GetAllBookmarksResult<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TPayload = unknown,
+    TResult = GetAllBookmarkResult<TVersion, TPayload>,
+> = ClientMethod<TResult>[TMethod];
+
+export type GetAllBookmarkResult<
+    TVersion extends ApiVersions,
+    TPayload,
+> = GetAllBookmarksVersions<TPayload>[TVersion]['result'];
+
+export type GetAllBookmarksVersions<TPayload = unknown> = {
+    ['v1']: { result: Array<ApiBookmarkEntityV1<TPayload>> };
+};
+
+export type ApiVersions = keyof GetAllBookmarksVersions<unknown>;

package/src/bookmarks/index.ts

@@ -0,0 +1,4 @@
+export { BookmarksApiClient, default } from './client';
+
+export * from './api-models';
+export * from './types';

package/src/bookmarks/patch/client.ts

@@ -0,0 +1,30 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { generateParameters } from './generate-parameters';
+import { ApiVersions, PatchBookmarkArgs, PatchBookmarkResult, PatchBookmarksResult } from './types';
+
+/**
+ * Method for updating bookmark
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const patchBookmark =
+    <
+        TClient extends IHttpClient = IHttpClient,
+        TVersion extends ApiVersions = ApiVersions,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod,
+    ) =>
+    <TResult = PatchBookmarkResult<TVersion, unknown>>(
+        args: PatchBookmarkArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResult>,
+    ): PatchBookmarksResult<TVersion, TMethod, unknown, TResult> =>
+        client[method](
+            ...generateParameters<TResult, TVersion, TClient>(version, args, init),
+        ) as PatchBookmarksResult<TVersion, TMethod, unknown, TResult>;
+
+export default patchBookmark;

package/src/bookmarks/patch/generate-endpoint.ts

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

package/src/bookmarks/patch/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, PatchBookmarkArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends ApiVersions,
+    TClient extends IHttpClient = IHttpClient,
+>(
+    version: TVersion,
+    args: PatchBookmarkArgs<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: 'patch', body: JSON.stringify(args), headers: headers },
+        init,
+    );
+
+    return [path, requestParams];
+};

package/src/bookmarks/patch/index.ts

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