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

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

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

package/dist/types/notification/types.d.ts

@@ -0,0 +1 @@
+export { ClientMethodType, ClientMethod, ApiClientArguments, } from '@equinor/fusion-framework-module-services';

package/dist/types/provider.d.ts

@@ -3,6 +3,7 @@ import { ClientMethod } from './types';
 import { ApiClientFactory } from './types';
 import { ContextApiClient } from './context';
 import BookmarksApiClient from './bookmarks/client';
+import { NotificationApiClient } from './notification';
 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>>;
@@ -13,6 +14,7 @@ type ApiProviderCtorArgs<TClient extends IHttpClient = IHttpClient> = {
 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>>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@equinor/fusion-framework-module-services",
-    "version": "2.0.7",
+    "version": "2.2.0",
     "description": "",
     "sideEffects": false,
     "main": "dist/esm/index.js",
@@ -10,6 +10,9 @@
             "*": [
                 "dist/types/*"
             ],
+            "notification": [
+                "dist/types/notification/index"
+            ],
             "context": [
                 "dist/types/context/index"
             ],
@@ -18,12 +21,17 @@
             ],
             "context/query": [
                 "dist/types/context/query/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",
         "./errors": "./dist/esm/errors.js",
         "./package.json": "./package.json"
@@ -48,12 +56,12 @@
     },
     "devDependencies": {
         "@equinor/fusion-framework-module": "^2.0.1",
-        "@equinor/fusion-framework-module-http": "^4.0.1",
-        "@equinor/fusion-framework-module-service-discovery": "^6.0.7"
+        "@equinor/fusion-framework-module-http": "^4.0.2",
+        "@equinor/fusion-framework-module-service-discovery": "^6.0.8"
     },
     "peerDependencies": {
         "@equinor/fusion-framework-module": ">=1.2.2",
         "odata-query": "^7.0.3"
     },
-    "gitHead": "a59959b7f25df08c9f93b05f1ea46980ff9e1303"
+    "gitHead": "8271bcdf843d09c67cb60a563cf32dbd9767e621"
 }

package/src/bookmarks/api-models.ts

@@ -8,8 +8,8 @@ export interface ApiBookmarkEntityV1<TPayload> {
     context: Context;
     createdBy: CreatedBy;
     updatedBy: UpdatedBy;
-    created: Date;
-    updated: Date;
+    created: string;
+    updated: string;
     sourceSystem: SourceSystem;
 }
 

package/src/bookmarks/client.ts

@@ -7,6 +7,12 @@ 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 getAllBookmarks, { GetAllBookmarkResult, GetAllBookmarksResult } from './getAll';
 
 export class BookmarksApiClient<
     TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
@@ -23,9 +29,19 @@ export class BookmarksApiClient<
         version: TVersion,
         ...args: Parameters<GetBookmarksFn<TVersion, TMethod, TClient, TPayload, TResult>>
     ): GetBookmarksResult<TVersion, TMethod, TPayload, TResult> {
-        const fn = getBookmark<TVersion, TMethod, TClient>(this._client, version, this._method);
+        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
@@ -35,7 +51,19 @@ export class BookmarksApiClient<
         version: TVersion,
         ...args: Parameters<PostBookmarkFn<TVersion, TMethod, TClient, TPayload, TResult>>
     ): PostBookmarksResult<TVersion, TMethod, TPayload, TResult> {
-        const fn = postBookmark<TVersion, TMethod, TClient>(this._client, version, this._method);
+        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);
     }
 

package/src/bookmarks/delete/client.ts

@@ -22,7 +22,7 @@ export const deleteBookmark =
     >(
         client: TClient,
         version: TVersion,
-        method: TMethod = 'json' as TMethod
+        method: TMethod = 'fetch' as TMethod
     ) =>
     <TResult = DeleteBookmarkResult<TVersion>>(
         args: DeleteBookmarkArgs<TVersion>,

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/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, PutBookmarkArgs, PutBookmarkResult, PutBookmarksResult } 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 putBookmark =
+    <
+        TClient extends IHttpClient = IHttpClient,
+        TVersion extends ApiVersions = ApiVersions,
+        TMethod extends keyof ClientMethod = keyof ClientMethod
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod
+    ) =>
+    <TResult = PutBookmarkResult<TVersion, unknown>>(
+        args: PutBookmarkArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResult>
+    ): PutBookmarksResult<TVersion, TMethod, unknown, TResult> =>
+        client[method](
+            ...generateParameters<TResult, TVersion, TClient>(version, args, init)
+        ) as PutBookmarksResult<TVersion, TMethod, unknown, TResult>;
+
+export default putBookmark;

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

@@ -0,0 +1,18 @@
+import { ApiVersions, PutBookmarkArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting bookmark by id
+ */
+export const generateEndpoint = <TVersion extends ApiVersions>(
+    version: TVersion,
+    _args: PutBookmarkArgs<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, PutBookmarkArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends ApiVersions,
+    TClient extends IHttpClient = IHttpClient
+>(
+    version: TVersion,
+    args: PutBookmarkArgs<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 { putBookmark, default } from './client';
+
+export { generateEndpoint as generatePutEndpoint } from './generate-endpoint';
+export { generateParameters as generatePutParameters } from './generate-parameters';

package/src/bookmarks/patch/types.ts

@@ -0,0 +1,45 @@
+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';
+import { PostBookmarksArgsV1 } from '../post';
+
+export type PutBookmarkResult<
+    TVersion extends ApiVersions,
+    TPayload
+> = PutBookmarksVersions<TPayload>[TVersion]['result'];
+
+/** Returns args for PutBookmark based on version*/
+export type PutBookmarkArgs<
+    TVersion extends ApiVersions,
+    TPayload = unknown
+> = PutBookmarksVersions<TPayload>[TVersion]['args'];
+
+/**Gets result type for PutBookmark call based on version and method */
+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> {
+    id: string;
+}
+
+export type PutBookmarksVersions<TPayload = unknown> = {
+    ['v1']: { args: PutBookmarksArgsV1<TPayload>; result: ApiBookmarkEntityV1<TPayload> };
+};
+
+export type ApiVersions = keyof PutBookmarksVersions<unknown>;

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

@@ -8,11 +8,7 @@ export const generateEndpoint = <TVersion extends ApiVersions>(
     _args: PostBookmarkArgs<TVersion>
 ) => {
     switch (version) {
-        case 'v1': {
-            const params = new URLSearchParams();
-            params.append('api-version', '1.0');
-            return `/bookmarks?${String(params)}`;
-        }
+        case 'v1':
         default: {
             const params = new URLSearchParams();
             params.append('api-version', version);

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

@@ -14,9 +14,7 @@ export const generateParameters = <
     init?: ClientRequestInit<TClient, TResult>
 ): ApiClientArguments<TClient, TResult> => {
     const path = generateEndpoint(version, args);
-    //add versions switch case later
 
-    //Not sure why this is needed, defaults to application/problem+json failing the request
     const headers = new Headers();
     headers.append('content-type', 'application/json');
 

package/src/bookmarks/post/types.ts

@@ -33,7 +33,7 @@ export type PostBookmarkFn<
     init?: ClientRequestInit<TClient, TResult>
 ) => PostBookmarksResult<TVersion, TMethod, TPayload, TResult>;
 
-type PostBookmarksArgsV1<T = unknown> = {
+export interface PostBookmarksArgsV1<T = unknown> {
     /** Display name of the bookmark */
     name: string;
     description?: string;
@@ -49,7 +49,7 @@ type PostBookmarksArgsV1<T = unknown> = {
         name?: string;
         subSystem?: string;
     };
-};
+}
 
 export type PostBookmarksVersions<TPayload = unknown> = {
     ['v1']: { args: PostBookmarksArgsV1<TPayload>; result: ApiBookmarkEntityV1<TPayload> };

package/src/notification/api-models.ts

@@ -0,0 +1,70 @@
+import { ApiVersion } from './static';
+
+type ApiNotificationEntity_v1 = {
+    id: string;
+    appKey: string;
+    emailPriority: number;
+    fallbackHtml: string;
+    targetAzureUniqueId: string;
+    title: string;
+    card: string;
+    created: string;
+    createdBy: CreatedBy_v1;
+    createdByApplication: CreatedByApplication_v1;
+    seenByUser: boolean;
+    seen: string;
+    sourceSystem: SourceSystem_v1;
+};
+
+type SourceSystem_v1 = {
+    name: string;
+    subSystem: string;
+    identifier: string;
+};
+
+type CreatedByApplication_v1 = {
+    id: string;
+    title: string;
+};
+
+type CreatedBy_v1 = {
+    id: string;
+    name: string;
+    jobTitle: string;
+    mail: string;
+    accountType: string;
+};
+
+type ApiNotificationEntity_v2 = unknown;
+
+type ApiNotificationEntityTypes = {
+    [ApiVersion.v1]: ApiNotificationEntity_v1;
+    [ApiVersion.v2]: ApiNotificationEntity_v2;
+};
+
+export type ApiNotificationEntity<T extends string = ApiVersion> = T extends ApiVersion
+    ? ApiNotificationEntityTypes[T]
+    : unknown;
+
+/**User notification Settings */
+type ApiNotificationSettingsEntity_v1 = {
+    email: boolean;
+    delayInMinutes: number;
+    appConfig: AppConfig_v1[];
+};
+
+type AppConfig_v1 = {
+    appKey: string;
+    enabled: boolean;
+};
+
+type ApiNotificationSettingsEntity_v2 = unknown;
+
+type ApiNotificationSettingEntityTypes = {
+    [ApiVersion.v1]: ApiNotificationSettingsEntity_v1;
+    [ApiVersion.v2]: ApiNotificationSettingsEntity_v2;
+};
+
+export type ApiNotificationSettingsEntity<T extends string = ApiVersion> = T extends ApiVersion
+    ? ApiNotificationSettingEntityTypes[T]
+    : unknown;

package/src/notification/client.ts

@@ -0,0 +1,167 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientMethod } from '../types';
+import { GetNotificationFn, GetNotificationResult } from './notification/get';
+import {
+    createNotification,
+    deleteNotification,
+    getNotificationById,
+    getNotifications,
+    updateSeenByUser,
+} from './notification';
+import { ApiVersion } from './static';
+import { PatchNotificationFn, PatchNotificationResult } from './notification/patch';
+import { GetNotificationsFn, GetNotificationsResult } from './notification/getAll';
+import { PostNotificationResult, PostNotificationFn } from './notification/post';
+import { DeleteNotificationFn, DeleteNotificationResult } from './notification/delete';
+import updateUserNotificationSettings, {
+    PutUserNotificationSettingsFn,
+    PutUserNotificationSettingsResult,
+} from './settings/put';
+import getUserNotificationSettings, {
+    GetUserNotificationSettingsFn,
+    GetUserNotificationsSettingsResult,
+} from './settings/get';
+
+export class NotificationApiClient<
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient
+> {
+    get Version(): typeof ApiVersion {
+        return ApiVersion;
+    }
+
+    constructor(protected _client: TClient, protected _method: TMethod) {}
+
+    /**
+     * Fetch all notifications
+     * @see {@link getAll/client}
+     */
+    public getAll<
+        TVersion extends string = keyof typeof ApiVersion,
+        TResult = GetNotificationsResult<TVersion>
+    >(
+        version: TVersion,
+        ...args: Parameters<GetNotificationsFn<TVersion, TMethod, TClient, TResult>>
+    ): GetNotificationsResult<TVersion, TMethod, TResult> {
+        const fn = getNotifications<TVersion, TMethod, TClient>(
+            this._client,
+            version,
+            this._method
+        );
+        return fn<TResult>(...args);
+    }
+
+    /**
+     * Fetch notification by id
+     * @see {@link getById/client}
+     */
+    public getById<
+        TVersion extends string = keyof typeof ApiVersion,
+        TResult = GetNotificationResult<TVersion>
+    >(
+        version: TVersion,
+        ...args: Parameters<GetNotificationFn<TVersion, TMethod, TClient, TResult>>
+    ): GetNotificationResult<TVersion, TMethod, TResult> {
+        const fn = getNotificationById<TVersion, TMethod, TClient>(
+            this._client,
+            version,
+            this._method
+        );
+        return fn<TResult>(...args);
+    }
+
+    /**
+     * Set notification seen by user
+     * @see {@link setSeenByUser/client}
+     */
+    public setSeenByUser<
+        TVersion extends string = keyof typeof ApiVersion,
+        TResult = PatchNotificationResult<TVersion>
+    >(
+        version: TVersion,
+        ...args: Parameters<PatchNotificationFn<TVersion, TMethod, TClient, TResult>>
+    ): PatchNotificationResult<TVersion, TMethod, TResult> {
+        const fn = updateSeenByUser<TVersion, TMethod, TClient>(
+            this._client,
+            version,
+            this._method
+        );
+        return fn<TResult>(...args);
+    }
+
+    /**
+     * Create a notification
+     * @see {@link create/client}
+     */
+    public create<
+        TVersion extends string = keyof typeof ApiVersion,
+        TResult = PostNotificationResult<TVersion>
+    >(
+        version: TVersion,
+        ...args: Parameters<PostNotificationFn<TVersion, TMethod, TClient, TResult>>
+    ): PostNotificationResult<TVersion, TMethod, TResult> {
+        const fn = createNotification<TVersion, TMethod, TClient>(
+            this._client,
+            version,
+            this._method
+        );
+        return fn<TResult>(...args);
+    }
+
+    /**
+     * Delete a notification
+     * @see {@link delete/client}
+     */
+    public delete<
+        TVersion extends string = keyof typeof ApiVersion,
+        TResult = PostNotificationResult<TVersion>
+    >(
+        version: TVersion,
+        ...args: Parameters<DeleteNotificationFn<TVersion, TMethod, TClient, TResult>>
+    ): DeleteNotificationResult<TVersion, TMethod, TResult> {
+        const fn = deleteNotification<TVersion, TMethod, TClient>(
+            this._client,
+            version,
+            this._method
+        );
+        return fn<TResult>(...args);
+    }
+    /**
+     * Get users notification settings
+     * @see {@link getSettings/client}
+     */
+    public getSettings<
+        TVersion extends string = keyof typeof ApiVersion,
+        TResult = PostNotificationResult<TVersion>
+    >(
+        version: TVersion,
+        ...args: Parameters<GetUserNotificationSettingsFn<TVersion, TMethod, TClient, TResult>>
+    ): GetUserNotificationsSettingsResult<TVersion, TMethod, TResult> {
+        const fn = getUserNotificationSettings<TVersion, TMethod, TClient>(
+            this._client,
+            version,
+            this._method
+        );
+        return fn<TResult>(...args);
+    }
+    /**
+     * Update user notification settings
+     * @see {@link updateSettings/client}
+     */
+    public updateSettings<
+        TVersion extends string = keyof typeof ApiVersion,
+        TResult = PostNotificationResult<TVersion>
+    >(
+        version: TVersion,
+        ...args: Parameters<PutUserNotificationSettingsFn<TVersion, TMethod, TClient, TResult>>
+    ): PutUserNotificationSettingsResult<TVersion, TMethod, TResult> {
+        const fn = updateUserNotificationSettings<TVersion, TMethod, TClient>(
+            this._client,
+            version,
+            this._method
+        );
+        return fn<TResult>(...args);
+    }
+}
+
+export default NotificationApiClient;