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

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;

package/src/notification/index.ts

@@ -0,0 +1,6 @@
+export { NotificationApiClient, default } from './client';
+
+export { ApiVersion } from './static';
+
+export * from './api-models';
+export * from './types';

package/src/notification/notification/delete/client.ts

@@ -0,0 +1,37 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiVersion } from '../../static';
+
+import { generateParameters } from './generate-parameters';
+
+import type {
+    DeleteNotificationArgs,
+    DeleteNotificationResponse,
+    DeleteNotificationResult,
+} from './types';
+
+/**
+ * Method for deleting notification item from notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const deleteNotification =
+    <
+        TVersion extends string = keyof typeof ApiVersion,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod
+    ) =>
+    <T = DeleteNotificationResponse<TVersion>>(
+        args: DeleteNotificationArgs<TVersion>,
+        init?: ClientRequestInit<TClient, T>
+    ): DeleteNotificationResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init)
+        ) as DeleteNotificationResult<TVersion, TMethod, T>;
+
+export default deleteNotification;

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

@@ -0,0 +1,24 @@
+import { UnsupportedApiVersion } from '@equinor/fusion-framework-module-services/errors';
+import { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+import type { DeleteNotificationArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting notification by id
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: DeleteNotificationArgs<TVersion>
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v2:
+            throw new UnsupportedApiVersion(version);
+        case ApiVersion.v1:
+        default: {
+            const { id } = args as { id: string };
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            return `/notification/${id}/?${String(params)}`;
+        }
+    }
+};

package/src/notification/notification/delete/generate-parameters.ts

@@ -0,0 +1,32 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion } from '../../static';
+import { ApiClientArguments } from '../../types';
+
+import { generateEndpoint } from './generate-endpoint';
+import { DeleteNotificationArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends string = keyof typeof ApiVersion,
+    TClient extends IHttpClient = IHttpClient
+>(
+    version: TVersion,
+    args: DeleteNotificationArgs<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: 'delete', headers: headers },
+        init
+    );
+
+    return [path, requestParams];
+};
+
+export default generateParameters;

package/src/notification/notification/delete/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { deleteNotification as getNotificationById, default } from './client';

package/src/notification/notification/delete/types.ts

@@ -0,0 +1,44 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type DeleteNotificationArgs_v1 = {
+    id: string;
+};
+
+type DeleteNotificationArgs_v2 = DeleteNotificationArgs_v1;
+
+type DeleteNotificationArgsTypes = {
+    [ApiVersion.v1]: DeleteNotificationArgs_v1;
+    [ApiVersion.v2]: DeleteNotificationArgs_v2;
+};
+
+export type DeleteNotificationArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? DeleteNotificationArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type DeleteNotificationResponseTypes = {
+    [ApiVersion.v1]: ApiNotificationEntity<ApiVersion.v1>;
+    [ApiVersion.v2]: ApiNotificationEntity<ApiVersion.v2>;
+};
+
+export type DeleteNotificationResponse<T> = T extends keyof typeof ApiVersion
+    ? DeleteNotificationResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type DeleteNotificationFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = DeleteNotificationResponse<TVersion>
+> = (
+    args: DeleteNotificationArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+) => DeleteNotificationResult<TVersion, TMethod, TResult>;
+
+export type DeleteNotificationResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = DeleteNotificationResponse<TVersion>
+> = ClientMethod<TResult>[TMethod];

package/src/notification/notification/get/client.ts

@@ -0,0 +1,33 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiVersion } from '../../static';
+
+import { generateParameters } from './generate-parameters';
+
+import type { GetNotificationArgs, GetNotificationResult, GetNotificationResponse } from './types';
+
+/**
+ * Method for fetching a notification item from notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const getNotificationById =
+    <
+        TVersion extends string = keyof typeof ApiVersion,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod
+    ) =>
+    <T = GetNotificationResponse<TVersion>>(
+        args: GetNotificationArgs<TVersion>,
+        init?: ClientRequestInit<TClient, T>
+    ): GetNotificationResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init)
+        ) as GetNotificationResult<TVersion, TMethod, T>;
+
+export default getNotificationById;

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

@@ -0,0 +1,25 @@
+import { UnsupportedApiVersion } from '@equinor/fusion-framework-module-services/errors';
+import { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+import type { GetNotificationArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting notification by id
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: GetNotificationArgs<TVersion>
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v2:
+            throw new UnsupportedApiVersion(version);
+        case ApiVersion.v1:
+        default: {
+            const { id } = args as { id: string };
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            return `/notification/${id}/?${String(params)}`;
+        }
+    }
+};

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

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

package/src/notification/notification/get/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { getNotificationById, default } from './client';

package/src/notification/notification/get/types.ts

@@ -0,0 +1,44 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type GetNotificationArgs_v1 = {
+    id: string;
+};
+
+type GetNotificationArgs_v2 = GetNotificationArgs_v1;
+
+type GetNotificationArgsTypes = {
+    [ApiVersion.v1]: GetNotificationArgs_v1;
+    [ApiVersion.v2]: GetNotificationArgs_v2;
+};
+
+export type GetNotificationArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? GetNotificationArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type GetNotificationResponseTypes = {
+    [ApiVersion.v1]: ApiNotificationEntity<ApiVersion.v1>;
+    [ApiVersion.v2]: ApiNotificationEntity<ApiVersion.v2>;
+};
+
+export type GetNotificationResponse<T> = T extends keyof typeof ApiVersion
+    ? GetNotificationResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type GetNotificationFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = GetNotificationResponse<TVersion>
+> = (
+    args: GetNotificationArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+) => GetNotificationResult<TVersion, TMethod, TResult>;
+
+export type GetNotificationResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = GetNotificationResponse<TVersion>
+> = ClientMethod<TResult>[TMethod];

package/src/notification/notification/getAll/client.ts

@@ -0,0 +1,37 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiVersion } from '../../static';
+
+import { generateParameters } from './generate-parameters';
+
+import type {
+    GetNotificationsArgs,
+    GetNotificationsResult,
+    GetNotificationsResponse,
+} from './types';
+
+/**
+ * Method for fetching all notifications item from notification service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const getNotifications =
+    <
+        TVersion extends string = keyof typeof ApiVersion,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod
+    ) =>
+    <T = GetNotificationsResponse<TVersion>>(
+        args: GetNotificationsArgs<TVersion>,
+        init?: ClientRequestInit<TClient, T>
+    ): GetNotificationsResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init)
+        ) as GetNotificationsResult<TVersion, TMethod, T>;
+
+export default getNotifications;

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

@@ -0,0 +1,25 @@
+import { UnsupportedApiVersion } from '@equinor/fusion-framework-module-services/errors';
+import { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+import type { GetNotificationsArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting all notifications
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: GetNotificationsArgs<TVersion>
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v2:
+            throw new UnsupportedApiVersion(version);
+        case ApiVersion.v1:
+        default: {
+            const { userId } = args as { userId: string };
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            return `/person/${userId}/notifications/?${String(params)}`;
+        }
+    }
+};

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

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

package/src/notification/notification/getAll/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { getNotifications, default } from './client';

package/src/notification/notification/getAll/types.ts

@@ -0,0 +1,44 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type GetNotificationsArgs_v1 = {
+    userId: string;
+};
+
+type GetNotificationsArgs_v2 = GetNotificationsArgs_v1;
+
+type GetNotificationsArgsTypes = {
+    [ApiVersion.v1]: GetNotificationsArgs_v1;
+    [ApiVersion.v2]: GetNotificationsArgs_v2;
+};
+
+export type GetNotificationsArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? GetNotificationsArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type GetNotificationResponseTypes = {
+    [ApiVersion.v1]: Array<ApiNotificationEntity<ApiVersion.v1>>;
+    [ApiVersion.v2]: Array<ApiNotificationEntity<ApiVersion.v2>>;
+};
+
+export type GetNotificationsResponse<T> = T extends keyof typeof ApiVersion
+    ? GetNotificationResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type GetNotificationsFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = GetNotificationsResponse<TVersion>
+> = (
+    args: GetNotificationsArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+) => GetNotificationsResult<TVersion, TMethod, TResult>;
+
+export type GetNotificationsResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = GetNotificationsResponse<TVersion>
+> = ClientMethod<TResult>[TMethod];

package/src/notification/notification/index.ts

@@ -0,0 +1,5 @@
+export { getNotificationById } from './get/client';
+export { createNotification } from './post/client';
+export { updateSeenByUser } from './patch/client';
+export { getNotifications } from './getAll/client';
+export { deleteNotification } from './delete/client';

package/src/notification/notification/patch/client.ts

@@ -0,0 +1,37 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiVersion } from '../../static';
+
+import { generateParameters } from './generate-parameters';
+
+import type {
+    PatchNotificationArgs,
+    PatchNotificationResponse,
+    PatchNotificationResult,
+} from './types';
+
+/**
+ * Method for updating a notification item
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const updateSeenByUser =
+    <
+        TVersion extends string = keyof typeof ApiVersion,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod
+    ) =>
+    <T = PatchNotificationResponse<TVersion>>(
+        args: PatchNotificationArgs<TVersion>,
+        init?: ClientRequestInit<TClient, T>
+    ): PatchNotificationResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init)
+        ) as PatchNotificationResult<TVersion, TMethod, T>;
+
+export default updateSeenByUser;