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

package/dist/types/bookmarks/favorites/head/types.d.ts

@@ -0,0 +1,17 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+export type HeadBookmarkFavoriteResult<TVersion extends ApiVersions> = HeadBookmarksFavoriteVersions[TVersion]['result'];
+export type HeadBookmarkFavoriteArgs<TVersion extends ApiVersions> = HeadBookmarksFavoriteVersions[TVersion]['args'];
+export type HeadBookmarksFavoriteResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = HeadBookmarkFavoriteResult<TVersion>> = ClientMethod<TResult>[TMethod];
+export type HeadBookmarkFavoriteFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = HeadBookmarkFavoriteResult<TVersion>> = (args: HeadBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => HeadBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+export interface HeadBookmarksFavoriteArgsV1 {
+    bookmarkId: string;
+}
+export type HeadBookmarksFavoriteVersions = {
+    ['v1']: {
+        args: HeadBookmarksFavoriteArgsV1;
+        result: Response;
+    };
+};
+export type ApiVersions = keyof HeadBookmarksFavoriteVersions;

package/dist/types/bookmarks/favorites/post/client.d.ts

@@ -0,0 +1,5 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { PostBookmarkFavoriteArgs, PostBookmarkFavoriteResult, PostBookmarksFavoriteResult } from './types';
+export declare const addBookmarkFavorite: <TVersion extends "v1" = "v1", 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>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PostBookmarkFavoriteResult<TVersion>>(args: PostBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => PostBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+export default addBookmarkFavorite;

package/dist/types/bookmarks/favorites/post/generate-endpoint.d.ts

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

package/dist/types/bookmarks/favorites/post/generate-parameters.d.ts

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

package/dist/types/bookmarks/favorites/post/index.d.ts

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

package/dist/types/bookmarks/favorites/post/types.d.ts

@@ -0,0 +1,17 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+export type PostBookmarkFavoriteResult<TVersion extends ApiVersions> = PostBookmarksFavoriteVersions[TVersion]['result'];
+export type PostBookmarkFavoriteArgs<TVersion extends ApiVersions> = PostBookmarksFavoriteVersions[TVersion]['args'];
+export type PostBookmarksFavoriteResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = PostBookmarkFavoriteResult<TVersion>> = ClientMethod<TResult>[TMethod];
+export type PostBookmarkFavoriteFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = PostBookmarkFavoriteResult<TVersion>> = (args: PostBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PostBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+export interface PostBookmarksFavoriteArgsV1 {
+    bookmarkId: string;
+}
+export type PostBookmarksFavoriteVersions = {
+    ['v1']: {
+        args: PostBookmarksFavoriteArgsV1;
+        result: Response;
+    };
+};
+export type ApiVersions = keyof PostBookmarksFavoriteVersions;

package/dist/types/bookmarks/get/client.d.ts

@@ -0,0 +1,5 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { GetBookmarkArgs, GetBookmarkResult, GetBookmarksResult } from './types';
+export declare const getBookmark: <TVersion extends "v1" = "v1", 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>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = GetBookmarkResult<TVersion, unknown>>(args: GetBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => GetBookmarksResult<TVersion, TMethod, unknown, TResult>;
+export default getBookmark;

package/dist/types/bookmarks/get/generate-endpoint.d.ts

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

package/dist/types/bookmarks/get/generate-parameters.d.ts

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

package/dist/types/bookmarks/get/index.d.ts

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

package/dist/types/bookmarks/get/types.d.ts

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

package/dist/types/bookmarks/getAll/client.d.ts

@@ -0,0 +1,5 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { GetAllBookmarkResult, GetAllBookmarksResult } from './types';
+export declare const getAllBookmarks: <TVersion extends "v1" = "v1", 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>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = GetAllBookmarkResult<TVersion, unknown>>(init?: ClientRequestInit<TClient, TResult> | undefined) => GetAllBookmarksResult<TVersion, TMethod, unknown, TResult>;
+export default getAllBookmarks;

package/dist/types/bookmarks/getAll/generate-endpoint.d.ts

@@ -0,0 +1 @@
+export declare const generateEndpoint: <TVersion extends "v1">(version: TVersion) => string;

package/dist/types/bookmarks/getAll/generate-parameters.d.ts

@@ -0,0 +1,3 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiClientArguments } from '../types';
+export declare const generateParameters: <TResult, TVersion extends "v1", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;

package/dist/types/bookmarks/getAll/index.d.ts

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

package/dist/types/bookmarks/getAll/types.d.ts

@@ -0,0 +1,10 @@
+import { ApiBookmarkEntityV1 } from '../api-models';
+import { ClientMethod } from '../types';
+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/dist/types/bookmarks/index.d.ts

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

package/dist/types/bookmarks/patch/client.d.ts

@@ -0,0 +1,5 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { PatchBookmarkArgs, PatchBookmarkResult, PatchBookmarksResult } from './types';
+export declare const patchBookmark: <TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod = keyof ClientMethod>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PatchBookmarkResult<TVersion, unknown>>(args: PatchBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => PatchBookmarksResult<TVersion, TMethod, unknown, TResult>;
+export default patchBookmark;

package/dist/types/bookmarks/patch/generate-endpoint.d.ts

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

package/dist/types/bookmarks/patch/generate-parameters.d.ts

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

package/dist/types/bookmarks/patch/index.d.ts

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

package/dist/types/bookmarks/patch/types.d.ts

@@ -0,0 +1,19 @@
+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 PatchBookmarkResult<TVersion extends ApiVersions, TPayload> = PatchBookmarksVersions<TPayload>[TVersion]['result'];
+export type PatchBookmarkArgs<TVersion extends ApiVersions, TPayload = unknown> = PatchBookmarksVersions<TPayload>[TVersion]['args'];
+export type PatchBookmarksResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TPayload = unknown, TResult = PatchBookmarkResult<TVersion, TPayload>> = ClientMethod<TResult>[TMethod];
+export type PatchBookmarkFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TPayload = unknown, TResult = PatchBookmarkResult<TVersion, TPayload>> = (args: PatchBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PatchBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+export interface PatchBookmarksArgsV1<T = unknown> extends Partial<PostBookmarksArgsV1<T>> {
+    id: string;
+}
+export type PatchBookmarksVersions<TPayload = unknown> = {
+    ['v1']: {
+        args: PatchBookmarksArgsV1<TPayload>;
+        result: ApiBookmarkEntityV1<TPayload>;
+    };
+};
+export type ApiVersions = keyof PatchBookmarksVersions<unknown>;

package/dist/types/bookmarks/post/client.d.ts

@@ -0,0 +1,5 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { PostBookmarkArgs, PostBookmarkResult, PostBookmarksResult } from './types';
+export declare const postBookmark: <TVersion extends "v1" = "v1", 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>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PostBookmarkResult<TVersion, unknown>>(args: PostBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => PostBookmarksResult<TVersion, TMethod, unknown, TResult>;
+export default postBookmark;

package/dist/types/bookmarks/post/generate-endpoint.d.ts

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

package/dist/types/bookmarks/post/generate-parameters.d.ts

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

package/dist/types/bookmarks/post/index.d.ts

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

package/dist/types/bookmarks/post/types.d.ts

@@ -0,0 +1,28 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { ApiBookmarkEntityV1 } from '../api-models';
+export type PostBookmarkResult<TVersion extends ApiVersions, TPayload> = PostBookmarksVersions<TPayload>[TVersion]['result'];
+export type PostBookmarkArgs<TVersion extends ApiVersions, TPayload = unknown> = PostBookmarksVersions<TPayload>[TVersion]['args'];
+export type PostBookmarksResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TPayload = unknown, TResult = PostBookmarkResult<TVersion, TPayload>> = ClientMethod<TResult>[TMethod];
+export type PostBookmarkFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TPayload = unknown, TResult = PostBookmarkResult<TVersion, TPayload>> = (args: PostBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PostBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+export interface PostBookmarksArgsV1<T = unknown> {
+    name: string;
+    description?: string;
+    isShared: boolean;
+    appKey: string;
+    contextId?: string;
+    payload: T;
+    sourceSystem?: {
+        identifier?: string;
+        name?: string;
+        subSystem?: string;
+    };
+}
+export type PostBookmarksVersions<TPayload = unknown> = {
+    ['v1']: {
+        args: PostBookmarksArgsV1<TPayload>;
+        result: ApiBookmarkEntityV1<TPayload>;
+    };
+};
+export type ApiVersions = keyof PostBookmarksVersions<unknown>;

package/dist/types/bookmarks/types.d.ts

@@ -0,0 +1 @@
+export { ClientMethodType, ClientMethod, ApiClientArguments } from '..';

package/dist/types/configurator.d.ts

@@ -0,0 +1,6 @@
+import { ApiClientFactory } from './types';
+export interface IApiConfigurator {
+    createClient?: ApiClientFactory;
+}
+export declare class ApiConfigurator implements IApiConfigurator {
+}

package/dist/types/context/api-models.d.ts

@@ -0,0 +1,31 @@
+import { ApiVersion } from './static';
+type ApiContextEntity_v1 = {
+    id: string;
+    externalId: string | null;
+    source: string | null;
+    type: ApiContextType_v1;
+    value: Record<string, unknown> | null;
+    title: string | null;
+    isActive: boolean;
+    isDeleted: boolean;
+    created: string;
+    updated: string | null;
+};
+type ApiContextEntity_v2 = unknown;
+type ApiContextEntityTypes = {
+    [ApiVersion.v1]: ApiContextEntity_v1;
+    [ApiVersion.v2]: ApiContextEntity_v2;
+};
+export type ApiContextEntity<T extends string = ApiVersion> = T extends ApiVersion ? ApiContextEntityTypes[T] : unknown;
+type ApiContextType_v1 = {
+    id: string;
+    isChildType: boolean;
+    parentTypeIds: string[] | null;
+};
+type ApiContextType_v2 = unknown;
+type ApiContextTypeTypes = {
+    [ApiVersion.v1]: ApiContextType_v1;
+    [ApiVersion.v2]: ApiContextType_v2;
+};
+export type ApiContextType<T extends ApiVersion> = ApiContextTypeTypes[T];
+export {};

package/dist/types/context/client.d.ts

@@ -0,0 +1,16 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import type { ClientMethod } from './types';
+import { ApiVersion } from './static';
+import { GetContextFn, GetContextResponse, GetContextResult } from './get';
+import { QueryContextFn, QueryContextResponse, QueryContextResult } from './query';
+import { RelatedContextFn, RelatedContextResponse, RelatedContextResult } from './related';
+export declare class ContextApiClient<TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient> {
+    protected _client: TClient;
+    protected _method: TMethod;
+    get Version(): typeof ApiVersion;
+    constructor(_client: TClient, _method: TMethod);
+    get<TVersion extends string = keyof typeof ApiVersion, TResult = GetContextResponse<TVersion>>(version: TVersion, ...args: Parameters<GetContextFn<TVersion, TMethod, TClient, TResult>>): GetContextResult<TVersion, TMethod, TResult>;
+    query<TVersion extends string = keyof typeof ApiVersion, TResult = QueryContextResponse<TVersion>>(version: TVersion, ...args: Parameters<QueryContextFn<TVersion, TMethod, TClient, TResult>>): QueryContextResult<TVersion, TMethod, TResult>;
+    related<TVersion extends string = keyof typeof ApiVersion, TResult = RelatedContextResponse<TVersion>>(version: TVersion, ...args: Parameters<RelatedContextFn<TVersion, TMethod, TClient, TResult>>): RelatedContextResult<TVersion, TMethod, TResult>;
+}
+export default ContextApiClient;

package/dist/types/context/get/client.d.ts

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod, GetContextArgs, GetContextResponse, GetContextResult } from './types';
+export declare const getContext: <TVersion extends string = "v1" | "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>>(client: TClient, version: TVersion, method?: TMethod) => <T = GetContextResponse<TVersion>>(args: GetContextArgs<TVersion>, init?: ClientRequestInit<TClient, T> | undefined) => GetContextResult<TVersion, TMethod, T>;
+export default getContext;

package/dist/types/context/get/generate-endpoint.d.ts

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

package/dist/types/context/get/generate-parameters.d.ts

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

package/dist/types/context/get/index.d.ts

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

package/dist/types/context/get/types.d.ts

@@ -0,0 +1,19 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion, ApiContextEntity, ClientMethod } from '..';
+export { ApiClientArguments, ClientMethod } from '..';
+type GetContextArgs_v1 = {
+    id: string;
+};
+type GetContextArgs_v2 = GetContextArgs_v1;
+type GetContextArgsTypes = {
+    [ApiVersion.v1]: GetContextArgs_v1;
+    [ApiVersion.v2]: GetContextArgs_v2;
+};
+export type GetContextArgs<T extends string> = T extends keyof typeof ApiVersion ? GetContextArgsTypes[(typeof ApiVersion)[T]] : unknown;
+type GetContextResponseTypes = {
+    [ApiVersion.v1]: ApiContextEntity<ApiVersion.v1>;
+    [ApiVersion.v2]: ApiContextEntity<ApiVersion.v2>;
+};
+export type GetContextResponse<T> = T extends keyof typeof ApiVersion ? GetContextResponseTypes[(typeof ApiVersion)[T]] : unknown;
+export type GetContextFn<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = GetContextResponse<TVersion>> = (args: GetContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => GetContextResult<TVersion, TMethod, TResult>;
+export type GetContextResult<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = GetContextResponse<TVersion>> = ClientMethod<TResult>[TMethod];

package/dist/types/context/index.d.ts

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

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

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { QueryContextArgs, QueryContextResponse, QueryContextResult, ClientMethod } from './types';
+export declare const queryContext: <TVersion extends string = "v1" | "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>>(client: TClient, version: TVersion, method?: TMethod) => <T = QueryContextResponse<TVersion>>(args: QueryContextArgs<TVersion>, init?: ClientRequestInit<TClient, T> | undefined) => QueryContextResult<TVersion, TMethod, T>;
+export default queryContext;

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

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion, ApiContextEntity, ClientMethod } from '..';
+export { ApiClientArguments, ClientMethod } from '..';
+export type QueryContextOdataFilter = {
+    type?: string[];
+    externalId?: string;
+};
+export type QueryContextOdataParameters = {
+    search?: string;
+    filter?: QueryContextOdataFilter;
+};
+type QueryContextArgs_v1 = {
+    query: string | QueryContextOdataParameters;
+    includeDeleted?: boolean;
+};
+type QueryContextArgs_v2 = QueryContextArgs_v1;
+type SearchContextArgTypes = {
+    [ApiVersion.v1]: QueryContextArgs_v1;
+    [ApiVersion.v2]: QueryContextArgs_v2;
+};
+export type QueryContextArgs<T> = T extends keyof typeof ApiVersion ? SearchContextArgTypes[(typeof ApiVersion)[T]] : {
+    query: {
+        search: string;
+    };
+};
+type QueryContextResponseTypes = {
+    [ApiVersion.v1]: Array<ApiContextEntity<ApiVersion.v1>>;
+    [ApiVersion.v2]: Array<ApiContextEntity<ApiVersion.v2>>;
+};
+export type QueryContextResponse<T> = T extends keyof typeof ApiVersion ? QueryContextResponseTypes[(typeof ApiVersion)[T]] : unknown;
+export type QueryContextFn<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = QueryContextResponse<TVersion>> = (args: QueryContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => QueryContextResult<TVersion, TMethod, TResult>;
+export type QueryContextResult<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = QueryContextResponse<TVersion>> = ClientMethod<TResult>[TMethod];

package/dist/types/context/related/client.d.ts

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { RelatedContextArgs, RelatedContextResponse, RelatedContextResult, ClientMethod } from './types';
+export declare const relatedContexts: <TVersion extends string = "v1" | "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>>(client: TClient, version: TVersion, method?: TMethod) => <T = RelatedContextResponse<TVersion>>(args: RelatedContextArgs<TVersion>, init?: ClientRequestInit<TClient, T> | undefined) => RelatedContextResult<TVersion, TMethod, T>;
+export default relatedContexts;

package/dist/types/context/related/generate-endpoint.d.ts

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

package/dist/types/context/related/generate-parameters.d.ts

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

package/dist/types/context/related/index.d.ts

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

package/dist/types/context/related/types.d.ts

@@ -0,0 +1,33 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion, ApiContextEntity, ClientMethod } from '..';
+export { ApiClientArguments, ClientMethod } from '..';
+export type ApiRelatedContextEntity<T extends ApiVersion> = ApiContextEntity<T> & {
+    relationSource: string;
+    relationType: unknown;
+};
+export type RelatedContextOdataFilter = {
+    type?: string[];
+};
+export type RelatedContextOdataParameters = {
+    search?: string;
+    filter?: RelatedContextOdataFilter;
+};
+type RelatedContextArgs_v1 = {
+    id: string;
+    query?: string | RelatedContextOdataParameters;
+};
+type RelatedContextArgs_v2 = RelatedContextArgs_v1;
+type RelatedContextArgTypes = {
+    [ApiVersion.v1]: RelatedContextArgs_v1;
+    [ApiVersion.v2]: RelatedContextArgs_v2;
+};
+export type RelatedContextArgs<T> = T extends keyof typeof ApiVersion ? RelatedContextArgTypes[(typeof ApiVersion)[T]] : {
+    id: string;
+};
+type RelatedContextResponseTypes = {
+    [ApiVersion.v1]: Array<ApiRelatedContextEntity<ApiVersion.v1>>;
+    [ApiVersion.v2]: Array<ApiRelatedContextEntity<ApiVersion.v2>>;
+};
+export type RelatedContextResponse<T> = T extends keyof typeof ApiVersion ? RelatedContextResponseTypes[(typeof ApiVersion)[T]] : unknown;
+export type RelatedContextFn<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = RelatedContextResponse<TVersion>> = (args: RelatedContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => RelatedContextResult<TVersion, TMethod, TResult>;
+export type RelatedContextResult<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = RelatedContextResponse<TVersion>> = ClientMethod<TResult>[TMethod];

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

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

package/dist/types/context/types.d.ts

@@ -0,0 +1 @@
+export { ClientMethodType, ClientMethod, ApiClientArguments } from '..';

package/dist/types/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class UnsupportedApiVersion extends Error {
+    readonly version: string | number;
+    constructor(version: string | number, cause?: unknown);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export type { ServicesModule, ServicesModuleKey } from './module';
+export { ApiConfigurator, IApiConfigurator } from './configurator';
+export { ApiProvider, IApiProvider } from './provider';
+export { default, module, enableServices, configureServices } from './module';

package/dist/types/module.d.ts

@@ -0,0 +1,20 @@
+import type { IModuleConfigurator, IModulesConfigurator, Module } from '@equinor/fusion-framework-module';
+import type { HttpModule } from '@equinor/fusion-framework-module-http';
+import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
+import { IApiConfigurator } from './configurator';
+import { IApiProvider } from './provider';
+export type ServicesModuleKey = 'services';
+export declare const moduleKey: ServicesModuleKey;
+export type ServicesModule = Module<ServicesModuleKey, IApiProvider, IApiConfigurator, [
+    HttpModule,
+    ServiceDiscoveryModule
+]>;
+export declare const module: ServicesModule;
+export declare const enableServices: (config: IModulesConfigurator<any, any>) => void;
+export declare const configureServices: (configure: (configurator: IApiConfigurator) => void) => IModuleConfigurator<ServicesModule>;
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        services: ServicesModule;
+    }
+}
+export default module;

package/dist/types/notification/api-models.d.ts

@@ -0,0 +1,54 @@
+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;
+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;
+export {};