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

package/dist/types/people/person-details/types.d.ts

@@ -0,0 +1,30 @@
+import { ApiVersion } from '../static';
+import type { ApiManager } from '../api-models';
+import type { ApiCompanyInfo_v4, ApiPersonContract_v4, ApiPerson_v4, ApiPersonPosition_v4, ApiPersonRole_v4 } from '../api-models.v4';
+import { ClientMethod } from '../../types';
+export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v4'>;
+type ApiRequestArgsMap = {
+    [ApiVersion.v4]: {
+        azureId: string;
+        expand?: Array<keyof ExpandMap[ApiVersion.v4]>;
+    };
+};
+export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
+type ExpandMap = {
+    [ApiVersion.v4]: {
+        roles: Array<ApiPersonRole_v4>;
+        positions: Array<ApiPersonPosition_v4>;
+        contracts: Array<ApiPersonContract_v4>;
+        manager: ApiManager;
+        companies: Array<ApiCompanyInfo_v4>;
+    };
+};
+export type ApiRequestArgs<T extends SupportedApiVersion> = ApiRequestArgsMap[(typeof ApiVersion)[T]];
+type ApiResponseTypes<TArgs extends AllowedArgs> = {
+    [ApiVersion.v4]: TArgs['expand'] extends Array<keyof ExpandMap[ApiVersion.v4]> ? ApiPerson_v4 & {
+        [K in TArgs['expand'][number]]: ExpandMap[ApiVersion.v4][K];
+    } : ApiPerson_v4;
+};
+export type ApiResponse<T extends SupportedApiVersion, TArgs extends AllowedArgs> = ApiResponseTypes<TArgs>[(typeof ApiVersion)[T]];
+export type ApiResult<TVersion extends SupportedApiVersion, TArgs extends ApiRequestArgs<TVersion>, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion, TArgs>> = ClientMethod<TResult>[TMethod];
+export {};

package/dist/types/people/person-photo/client.d.ts

@@ -0,0 +1,5 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientDataMethod } from '../../types';
+import type { ApiResponse, ApiRequestArgs } from './types';
+export declare const client: <TVersion extends "v2", TMethod extends keyof ClientDataMethod = keyof ClientDataMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, TArgs extends ApiRequestArgs<TVersion> = ApiRequestArgs<TVersion>>(client: TClient, version: TVersion, method?: TMethod) => <T extends Blob = ApiResponse<TVersion>>(args: TArgs, init?: ClientRequestInit<TClient, T> | undefined) => ClientDataMethod[TMethod];
+export default client;

package/dist/types/people/person-photo/generate-endpoint.d.ts

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

package/dist/types/people/person-photo/generate-parameters.d.ts

@@ -0,0 +1,5 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiClientArguments } from '../../types';
+import type { ApiRequestArgs } from './types';
+export declare const generateParameters: <TResult, TVersion extends "v2", 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: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;
+export default generateParameters;

package/dist/types/people/person-photo/index.d.ts

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

package/dist/types/people/person-photo/types.d.ts

@@ -0,0 +1,16 @@
+import { ApiVersion } from '../static';
+import { ClientDataMethod } from '../../types';
+export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v2'>;
+type ApiRequestArgsMap = {
+    [ApiVersion.v2]: {
+        azureId: string;
+    };
+};
+export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
+export type ApiRequestArgs<T extends SupportedApiVersion> = ApiRequestArgsMap[(typeof ApiVersion)[T]];
+type ApiResponseTypes = {
+    [ApiVersion.v2]: Blob;
+};
+export type ApiResponse<T extends SupportedApiVersion> = ApiResponseTypes[(typeof ApiVersion)[T]];
+export type ApiResult<TMethod extends keyof ClientDataMethod = keyof ClientDataMethod> = ClientDataMethod[TMethod];
+export {};

package/dist/types/people/query/client.d.ts

@@ -0,0 +1,5 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod } from '../../types';
+import type { ApiResponse, ApiResult, ApiRequestArgs } from './types';
+export declare const client: <TVersion extends "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, TArgs extends ApiRequestArgs<TVersion> = ApiRequestArgs<TVersion>>(client: TClient, version: TVersion, method?: TMethod) => <T = ApiResponse<TVersion>>(args: TArgs, init?: ClientRequestInit<TClient, T> | undefined) => ApiResult<TVersion, TMethod, T>;
+export default client;

package/dist/types/people/query/generate-endpoint.d.ts

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

package/dist/types/people/query/generate-parameters.d.ts

@@ -0,0 +1,5 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiClientArguments } from '../../types';
+import type { ApiRequestArgs } from './types';
+export declare const generateParameters: <TResult, TVersion extends "v2", 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: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;
+export default generateParameters;

package/dist/types/people/query/index.d.ts

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

package/dist/types/people/query/types.d.ts

@@ -0,0 +1,17 @@
+import { ApiVersion } from '../static';
+import { ApiPerson_v2 } from '../api-models.v2';
+import { ClientMethod } from '../../types';
+export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v2'>;
+type ApiRequestArgsMap = {
+    [ApiVersion.v2]: {
+        search: string;
+    };
+};
+export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
+export type ApiRequestArgs<T extends SupportedApiVersion> = ApiRequestArgsMap[(typeof ApiVersion)[T]];
+type ApiResponseTypes = {
+    [ApiVersion.v2]: Array<ApiPerson_v2>;
+};
+export type ApiResponse<T extends SupportedApiVersion> = ApiResponseTypes[(typeof ApiVersion)[T]];
+export type ApiResult<TVersion extends SupportedApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
+export {};

package/dist/types/people/static.d.ts

@@ -0,0 +1,4 @@
+export declare enum ApiVersion {
+    'v2' = "2.0",
+    'v4' = "4.0"
+}

package/dist/types/provider.d.ts

@@ -0,0 +1,37 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientMethod } from './types';
+import { ApiClientFactory } from './types';
+import { ContextApiClient } from './context';
+import BookmarksApiClient from './bookmarks/client';
+import { NotificationApiClient } from './notification';
+import { PeopleApiClient } from './people/client';
+export interface IApiProvider<TClient extends IHttpClient = IHttpClient> {
+    createBookmarksClient<TMethod extends keyof ClientMethod, TPayload = unknown>(method: TMethod): Promise<BookmarksApiClient<TMethod, TClient, TPayload>>;
+    createContextClient<TMethod extends keyof ClientMethod>(method: TMethod): Promise<ContextApiClient<TMethod, TClient>>;
+    createNotificationClient<TMethod extends keyof ClientMethod>(method: TMethod): Promise<NotificationApiClient<TMethod, TClient>>;
+    createPeopleClient(): Promise<PeopleApiClient<TClient>>;
+}
+type ApiProviderCtorArgs<TClient extends IHttpClient = IHttpClient> = {
+    createClient: ApiClientFactory<TClient>;
+};
+type ApiProviderErrorResponse = {
+    type: ResponseType;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    url: string;
+    data: unknown;
+};
+export declare class ApiProviderError extends Error {
+    readonly response: ApiProviderErrorResponse;
+    constructor(msg: string, response: ApiProviderErrorResponse, options?: ErrorOptions);
+}
+export declare class ApiProvider<TClient extends IHttpClient = IHttpClient> implements IApiProvider<TClient> {
+    protected _createClientFn: ApiClientFactory<TClient>;
+    constructor({ createClient }: ApiProviderCtorArgs<TClient>);
+    createNotificationClient<TMethod extends keyof ClientMethod>(method: TMethod): Promise<NotificationApiClient<TMethod, TClient>>;
+    createBookmarksClient<TMethod extends keyof ClientMethod, TPayload = unknown>(method: TMethod): Promise<BookmarksApiClient<TMethod, TClient, TPayload>>;
+    createContextClient<TMethod extends keyof ClientMethod>(method: TMethod): Promise<ContextApiClient<TMethod, TClient>>;
+    createPeopleClient(): Promise<PeopleApiClient<TClient>>;
+}
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,17 @@
+import { ClientRequestInit, IHttpClient, FetchResponse, StreamResponse } from '@equinor/fusion-framework-module-http/client';
+export type ApiClientFactory<TClient extends IHttpClient = IHttpClient> = (name: string) => Promise<TClient>;
+export type ApiClientArguments<TClient extends IHttpClient, TResult = unknown> = [
+    path: string,
+    init?: ClientRequestInit<TClient, TResult>
+];
+export type ClientMethod<T = unknown> = {
+    fetch: Promise<FetchResponse<T>>;
+    json: Promise<T>;
+    fetch$: StreamResponse<FetchResponse<T>>;
+    json$: StreamResponse<T>;
+};
+export type ClientDataMethod = {
+    blob: Blob;
+    blob$: StreamResponse<Blob>;
+};
+export type ClientMethodType = keyof ClientMethod;

package/dist/types/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "3.1.5";

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@equinor/fusion-framework-module-services",
+  "version": "0.0.0-next-20230915111233",
+  "description": "",
+  "sideEffects": false,
+  "main": "dist/esm/index.js",
+  "types": "index.d.ts",
+  "typesVersions": {
+    ">=4.2": {
+      "*": [
+        "dist/types/*"
+      ],
+      "notification": [
+        "dist/types/notification/index"
+      ],
+      "context": [
+        "dist/types/context/index"
+      ],
+      "context/get": [
+        "dist/types/context/get/index"
+      ],
+      "context/query": [
+        "dist/types/context/query/index"
+      ],
+      "context/related": [
+        "dist/types/context/related/index"
+      ],
+      "people": [
+        "dist/types/people/index"
+      ],
+      "people/get": [
+        "dist/types/people/person-details/index"
+      ],
+      "people/query": [
+        "dist/types/people/query/index"
+      ],
+      "people/photo": [
+        "dist/types/people/person-photo/index"
+      ],
+      "bookmarks": [
+        "dist/types/bookmarks/index"
+      ]
+    }
+  },
+  "exports": {
+    ".": "./dist/esm/index.js",
+    "./context": "./dist/esm/context/index.js",
+    "./bookmark": "./dist/esm/bookmarks/index.js",
+    "./notification": "./dist/esm/notification/index.js",
+    "./context/get": "./dist/esm/context/get-context/index.js",
+    "./people": "./dist/esm/people/index.js",
+    "./people/get": "./dist/esm/people/person-details/index.js",
+    "./people/query": "./dist/esm/people/query/index.js",
+    "./people/photo": "./dist/esm/people/person-photo/index.js",
+    "./errors": "./dist/esm/errors.js",
+    "./package.json": "./package.json"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/equinor/fusion-framework.git",
+    "directory": "packages/modules/services"
+  },
+  "dependencies": {
+    "odata-query": "^7.0.4"
+  },
+  "devDependencies": {
+    "typescript": "^5.1.3",
+    "@equinor/fusion-framework-module": "^4.2.4",
+    "@equinor/fusion-framework-module-http": "^0.0.0-next-20230915111233",
+    "@equinor/fusion-framework-module-service-discovery": "^0.0.0-next-20230915111233"
+  },
+  "peerDependencies": {
+    "odata-query": "^7.0.4",
+    "@equinor/fusion-framework-module": "^4.2.4"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  }
+}

package/src/bookmarks/api-models.ts

@@ -0,0 +1,46 @@
+export interface ApiBookmarkEntityV1<TPayload> {
+    id: string;
+    name: string;
+    description: string;
+    isShared: boolean;
+    payload: TPayload;
+    appKey: string;
+    context: Context;
+    createdBy: CreatedBy;
+    updatedBy: UpdatedBy;
+    created: string;
+    updated: string;
+    sourceSystem: SourceSystem;
+}
+
+export interface Context {
+    id: string;
+    name: string;
+    type: string;
+}
+
+export interface CreatedBy {
+    azureUniqueId: string;
+    mail: string;
+    name: string;
+    phoneNumber: string;
+    jobTitle: string;
+    accountType: number;
+    accountClassification: number;
+}
+
+export interface UpdatedBy {
+    azureUniqueId: string;
+    mail: string;
+    name: string;
+    phoneNumber: string;
+    jobTitle: string;
+    accountType: number;
+    accountClassification: number;
+}
+
+export interface SourceSystem {
+    identifier: string;
+    name: string;
+    subSystem: string;
+}

package/src/bookmarks/client.ts

@@ -0,0 +1,132 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+
+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';
+
+export class BookmarksApiClient<
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TPayload = unknown,
+> {
+    constructor(
+        protected _client: TClient,
+        protected _method: TMethod,
+    ) {}
+
+    /**
+     * Fetch bookmark by id
+     * @see {@link get/client}
+     */
+    public get<TVersion extends ApiVersions, TResult = GetBookmarkResult<TVersion, TPayload>>(
+        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);
+    }
+    /**
+     * Fetch all bookmarks
+     * @see {@link get/client}
+     */
+    public getAll<TVersion extends ApiVersions, TResult = GetAllBookmarkResult<TVersion, TPayload>>(
+        version: TVersion,
+    ): GetAllBookmarksResult<TVersion, TMethod, TPayload, TResult> {
+        const fn = getAllBookmarks(this._client, version, this._method);
+        return fn<TResult>();
+    }
+
+    /**
+     * Create a new bookmark
+     * @see {@link get/client}
+     */
+    public post<TVersion extends ApiVersions, TResult = PostBookmarkResult<TVersion, TPayload>>(
+        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);
+    }
+
+    /**
+     * Update a bookmark
+     * @see {@link get/client}
+     */
+    public patch<TVersion extends ApiVersions, TResult = PatchBookmarkResult<TVersion, TPayload>>(
+        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);
+    }
+
+    /**
+     * Delete a bookmark
+     * @see {@link delete/client}
+     */
+    public delete<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<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);
+    }
+
+    /**
+     * 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/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,
+    DeleteBookmarkArgs,
+    DeleteBookmarkResult,
+    DeleteBookmarksResult,
+} 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 deleteBookmark =
+    <
+        TVersion extends ApiVersions = ApiVersions,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient,
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'fetch' as TMethod,
+    ) =>
+    <TResult = DeleteBookmarkResult<TVersion>>(
+        args: DeleteBookmarkArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResult>,
+    ): DeleteBookmarksResult<TVersion, TMethod, TResult> =>
+        client[method](
+            ...generateParameters<TResult, TVersion, TClient>(version, args, init),
+        ) as DeleteBookmarksResult<TVersion, TMethod, TResult>;
+
+export default deleteBookmark;

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

@@ -0,0 +1,24 @@
+import { ApiVersions, DeleteBookmarkArgs } from './types';
+
+/**
+ * Method for generating endpoint for deleting a bookmark.
+ */
+export const generateEndpoint = <TVersion extends ApiVersions>(
+    version: TVersion,
+    args: DeleteBookmarkArgs<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/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, DeleteBookmarkArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends ApiVersions,
+    TClient extends IHttpClient = IHttpClient,
+>(
+    version: TVersion,
+    args: DeleteBookmarkArgs<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/delete/index.ts

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

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

@@ -0,0 +1,2 @@
+/** arguments for v1 delete bookmarks */
+export type DeleteBookmarksArgsV1 = { id: string };

package/src/bookmarks/delete/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 '../..';
+import { DeleteBookmarksArgsV1 } from './types-v1';
+
+export type DeleteBookmarkResult<TVersion extends ApiVersions> =
+    DeleteBookmarksVersions[TVersion]['result'];
+
+/** Returns args for GetBookmark based on version*/
+export type DeleteBookmarkArgs<TVersion extends ApiVersions> =
+    DeleteBookmarksVersions[TVersion]['args'];
+
+/**Gets result type for GetBookmark call based on version and method */
+export type DeleteBookmarksResult<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = DeleteBookmarkResult<TVersion>,
+> = ClientMethod<TResult>[TMethod];
+
+export type DeleteBookmarksFn<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = DeleteBookmarkResult<TVersion>,
+> = (
+    args: DeleteBookmarkArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+) => DeleteBookmarksResult<TVersion, TMethod, TResult>;
+
+export type DeleteBookmarksVersions = {
+    ['v1']: { args: DeleteBookmarksArgsV1; result: undefined };
+};
+
+/**Api versions for bookmarks service */
+export type ApiVersions = keyof DeleteBookmarksVersions;

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/favourites/${bookmarkId}/?${String(params)}`;
+        }
+    }
+};