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

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 '../../../errors';
+import { ApiVersion } from '../..';
+
+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 '../..';
+
+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 '../../../errors';
+import { ApiVersion } from '../..';
+
+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 '../..';
+
+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;

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

@@ -0,0 +1,24 @@
+import { UnsupportedApiVersion } from '../../../errors';
+import { ApiVersion } from '../..';
+import type { PatchNotificationArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting notification by id
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: PatchNotificationArgs<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/patch/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 { PatchNotificationArgs } 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: PatchNotificationArgs<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];
+};
+
+export default generateParameters;

package/src/notification/notification/patch/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '../..';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { updateSeenByUser as getNotificationById, default } from './client';

package/src/notification/notification/patch/types.ts

@@ -0,0 +1,45 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type PatchNotificationArgs_v1 = {
+    id: string;
+    seenByUser: boolean;
+};
+
+type PatchNotificationArgs_v2 = PatchNotificationArgs_v1;
+
+type PatchNotificationArgsTypes = {
+    [ApiVersion.v1]: PatchNotificationArgs_v1;
+    [ApiVersion.v2]: PatchNotificationArgs_v2;
+};
+
+export type PatchNotificationArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? PatchNotificationArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type PatchNotificationResponseTypes = {
+    [ApiVersion.v1]: ApiNotificationEntity<ApiVersion.v1>;
+    [ApiVersion.v2]: ApiNotificationEntity<ApiVersion.v2>;
+};
+
+export type PatchNotificationResponse<T> = T extends keyof typeof ApiVersion
+    ? PatchNotificationResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type PatchNotificationFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = PatchNotificationResponse<TVersion>,
+> = (
+    args: PatchNotificationArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+) => PatchNotificationResult<TVersion, TMethod, TResult>;
+
+export type PatchNotificationResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = PatchNotificationResponse<TVersion>,
+> = ClientMethod<TResult>[TMethod];

package/src/notification/notification/post/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 {
+    PostNotificationArgs,
+    PostNotificationResult,
+    PostNotificationResponse,
+} from './types';
+
+/**
+ * Method for creating 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 createNotification =
+    <
+        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 = PostNotificationResponse<TVersion>>(
+        args: PostNotificationArgs<TVersion>,
+        init?: ClientRequestInit<TClient, T>,
+    ): PostNotificationResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init),
+        ) as PostNotificationResult<TVersion, TMethod, T>;
+
+export default createNotification;

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

@@ -0,0 +1,25 @@
+import { UnsupportedApiVersion } from '../../../errors';
+import { ApiVersion } from '../..';
+
+import type { PostNotificationArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting all notifications
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: PostNotificationArgs<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/post/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 { PostNotificationArgs } 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: PostNotificationArgs<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];
+};
+
+export default generateParameters;

package/src/notification/notification/post/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '../..';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { createNotification as getNotificationById, default } from './client';

package/src/notification/notification/post/types.ts

@@ -0,0 +1,57 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type SourceSystem_v1 = {
+    name: string;
+    subSystem: string;
+    identifier: string;
+};
+
+type PostNotificationArgs_v1 = {
+    appKey: string;
+    emailPriority: number;
+    fallbackHtml: string;
+    title: string;
+    description: string;
+    card: string;
+    sourceSystem: SourceSystem_v1;
+    originalCreatorUniqueId: string;
+};
+
+type PostNotificationArgs_v2 = PostNotificationArgs_v1;
+
+type PostNotificationArgsTypes = {
+    [ApiVersion.v1]: PostNotificationArgs_v1;
+    [ApiVersion.v2]: PostNotificationArgs_v2;
+};
+
+export type PostNotificationArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? PostNotificationArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type PostNotificationResponseTypes = {
+    [ApiVersion.v1]: Array<ApiNotificationEntity<ApiVersion.v1>>;
+    [ApiVersion.v2]: Array<ApiNotificationEntity<ApiVersion.v2>>;
+};
+
+export type PostNotificationResponse<T> = T extends keyof typeof ApiVersion
+    ? PostNotificationResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type PostNotificationFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = PostNotificationResponse<TVersion>,
+> = (
+    args: PostNotificationArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+) => PostNotificationResult<TVersion, TMethod, TResult>;
+
+export type PostNotificationResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = PostNotificationResponse<TVersion>,
+> = ClientMethod<TResult>[TMethod];