@azure-net/kit 3.9.1 → 3.9.2

package/dist/core/delivery/index.d.ts

@@ -1,4 +1 @@
-export * from '../../edges/index.js';
-export * from './injectableDependencies/index.js';
-export * from './serverAction/index.js';
-export * from './schema/index.js';
+export {};

package/dist/core/delivery/index.js

@@ -1,4 +1 @@
-export * from '../../edges/index.js';
-export * from './injectableDependencies/index.js';
-export * from './serverAction/index.js';
-export * from './schema/index.js';
+"use strict";

package/dist/core/delivery/injectableDependencies/AsyncHelpers.d.ts

@@ -1,42 +1,34 @@
-import { type AppError, createErrorParser } from './ErrorHandler.js';
-export interface AsyncActionResponse<T, D = unknown, CustomErrorField = never> {
+import { createErrorHandler } from './ErrorHandler.js';
+import { type AppError, type IAppError } from '../../shared/appError/AppError.js';
+export interface AsyncActionResponse<T, D = never, ErrorResult = Record<never, never>> {
     success: boolean;
     response: T;
-    error?: AppError<D, CustomErrorField>;
+    error?: IAppError<D> & ErrorResult;
 }
-type ActionOrThunk<Res> = Promise<Res> | (() => Promise<Res>);
-export declare const createAsyncHelpers: <BaseError = unknown, Custom = unknown>(opts?: {
-    parseError?: ReturnType<typeof createErrorParser<BaseError, Custom>>;
+export interface AsyncHelperRetry {
+    can: boolean;
+    call?: () => Promise<Error | void>;
+}
+type Action<Res> = () => Promise<Res>;
+export interface AsyncActionSettings<Res = never, Req = never, ErrorResult = AppError<Error>> {
+    beforeSend?: (actions: {
+        next: () => void;
+        abort: (reason?: Error) => void;
+    }) => void | Promise<void>;
+    onSuccess?: (result: AsyncActionResponse<Res, never, ErrorResult>) => Promise<unknown> | unknown;
+    onError?: (result: AsyncActionResponse<never, Req, ErrorResult>) => Promise<unknown> | unknown;
+    fallbackResponse?: Res;
+}
+export interface AsyncResourceSettings<Res = never, Req = never, ErrorResult = AppError<Error>> extends AsyncActionSettings<Res, Req, ErrorResult> {
+    reject?: boolean;
+}
+export declare class AsyncHelperError extends Error {
+}
+export declare const createAsyncHelpers: <ErrorResult extends object>(opts?: {
+    handler?: ReturnType<typeof createErrorHandler<ErrorResult>>;
 }) => {
-    createAsyncAction: <Res = unknown, Req = unknown>(action: ActionOrThunk<Res>, args?: {
-        beforeSend?: (actions: {
-            next: () => void;
-            abort: () => void;
-        }) => void | Promise<void>;
-        onSuccess?: (result: AsyncActionResponse<Res, undefined, Custom>) => Promise<unknown> | unknown;
-        onError?: (result: AsyncActionResponse<never, Req, Custom>) => Promise<unknown> | unknown;
-        reject?: boolean;
-        abort?: {
-            condition: boolean;
-            onAbort?: () => void;
-        };
-        fallbackResponse?: Res;
-        maxRetries?: number;
-    }) => Promise<AsyncActionResponse<Res, Req, Custom>>;
-    createAsyncResource: <Res, Req_1 = unknown>(action: ActionOrThunk<Res>, args?: {
-        beforeSend?: (actions: {
-            next: () => void;
-            abort: () => void;
-        }) => void | Promise<void>;
-        onSuccess?: (result: Res) => Promise<unknown> | unknown;
-        onError?: (error: AppError<Req_1, Custom>) => Promise<unknown> | unknown;
-        reject?: boolean;
-        abort?: {
-            condition: boolean;
-            onAbort?: () => void;
-        };
-        fallbackResponse?: Res;
-        maxRetries?: number;
-    }) => Promise<Res>;
+    createAsyncAction: <Res = never, Req = never>(action: Action<Res>, args?: AsyncActionSettings<Res, Req, ErrorResult>) => Promise<AsyncActionResponse<Res, Req, ErrorResult>>;
+    createAsyncResource: <Res = never, Req_1 = never>(action: Action<Res>, args?: AsyncResourceSettings<Res, Req_1, ErrorResult>) => Promise<Res>;
+    errorParser: <T = unknown>(error: Error, asyncHelperRetry?: AsyncHelperRetry) => Promise<IAppError<T> & ErrorResult>;
 };
 export {};

package/dist/core/delivery/injectableDependencies/AsyncHelpers.js

@@ -1,68 +1,74 @@
-import { createErrorParser } from './ErrorHandler.js';
-import { AppEvents } from '../../index.js';
+import { createErrorHandler } from './ErrorHandler.js';
+import {} from '../../shared/appError/AppError.js';
+export class AsyncHelperError extends Error {
+}
 export const createAsyncHelpers = (opts) => {
-    const errorParser = opts?.parseError ?? createErrorParser();
-    const createAsyncAction = async (action, args) => {
-        if (args?.abort?.condition) {
-            args.abort.onAbort?.();
-            const abortError = {
-                type: 'abort',
-                message: 'aborted',
-                original: new Error('aborted')
-            };
-            if (args?.reject)
-                throw abortError;
-            return {
-                success: false,
-                error: abortError,
-                response: args?.fallbackResponse
-            };
-        }
-        if (args?.beforeSend) {
-            const beforeSendResult = await new Promise((resolve) => {
-                let settled = false;
-                const settle = (value) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    resolve(value);
-                };
-                const next = () => settle('next');
-                const abort = () => settle('abort');
-                Promise.resolve(args.beforeSend({ next, abort }))
-                    .then(() => {
-                    settle('next');
+    const errorParser = opts?.handler ?? createErrorHandler();
+    const normalizeError = (err) => (err instanceof Error ? err : new Error(String(err)));
+    const prepareErrors = async (error, retry) => {
+        let retryResult = undefined;
+        const retryFunc = async () => {
+            if (retry) {
+                return await retry()
+                    .then((res) => {
+                    retryResult = res;
+                    return undefined;
                 })
-                    .catch((err) => {
-                    console.error('Error in beforeSend:', err);
-                    settle('abort');
-                });
-            });
-            if (beforeSendResult === 'abort') {
-                const abortError = {
-                    type: 'abort',
-                    message: 'Aborted in beforeSend',
-                    original: new Error('Aborted in beforeSend')
-                };
-                if (args?.reject)
-                    throw abortError;
-                return {
-                    success: false,
-                    error: abortError,
-                    response: args?.fallbackResponse
-                };
+                    .catch((err) => normalizeError(err));
             }
-        }
-        const maxRetries = args?.maxRetries ?? 3;
-        let retries = 0;
-        const req = async (isRetry = false) => {
-            if (isRetry) {
-                retries++;
-                if (retries > maxRetries) {
-                    return Promise.reject(Error('Max retries reached'));
+        };
+        const parsedError = await errorParser(normalizeError(error), { can: !!retry, call: retry ? () => retryFunc() : undefined });
+        return { error: parsedError, retryResult };
+    };
+    const beforeSendResolver = async (settings) => {
+        if (!settings?.beforeSend)
+            return undefined;
+        let abortReason;
+        let aborted = false;
+        await new Promise((resolve) => {
+            let settled = false;
+            const beforeSend = settings.beforeSend;
+            const guardTimer = setTimeout(() => {
+                settle(true);
+            }, 30000);
+            const settle = (isAbort, reason) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(guardTimer);
+                aborted = isAbort;
+                abortReason = reason;
+                resolve();
+            };
+            const next = () => settle(false);
+            const abort = (reason) => settle(true, reason);
+            try {
+                const maybePromise = beforeSend({ next, abort });
+                if (maybePromise && typeof maybePromise.then === 'function') {
+                    maybePromise.then(() => settle(false), (err) => settle(true, normalizeError(err)));
+                    return;
                 }
+                settle(false);
             }
-            const response = await Promise.resolve(typeof action === 'function' ? action() : action);
+            catch (err) {
+                settle(true, normalizeError(err));
+            }
+        });
+        if (!aborted)
+            return undefined;
+        const { error } = await prepareErrors(abortReason ?? new AsyncHelperError('Aborted in beforeSend'));
+        return {
+            success: false,
+            error,
+            response: undefined
+        };
+    };
+    const createAsyncAction = async (action, args) => {
+        const beforeSendResult = await beforeSendResolver(args);
+        if (beforeSendResult)
+            return beforeSendResult;
+        const req = async () => {
+            const response = await Promise.resolve(action());
             const result = { response, success: true };
             await args?.onSuccess?.(result);
             return result;
@@ -71,94 +77,30 @@ export const createAsyncHelpers = (opts) => {
             return await req();
         }
         catch (err) {
-            let retryResult;
-            const retry = async () => await req(true)
-                .then((res) => (retryResult = res))
-                .catch(() => undefined);
-            const error = await errorParser(err, async () => await retry());
+            const { error, retryResult } = await prepareErrors(normalizeError(err), async () => await req());
             if (retryResult) {
                 return retryResult;
             }
-            const { bus } = AppEvents();
-            bus.publish('OnAsyncHelperError', () => error);
             const result = { error, response: args?.fallbackResponse, success: false };
-            await args?.onError?.(result);
-            if (args?.reject)
-                throw error;
+            try {
+                await args?.onError?.(result);
+            }
+            catch (err) {
+                throw await errorParser(new AsyncHelperError('onError caught exception', { cause: normalizeError(err) }));
+            }
             return result;
         }
     };
     const createAsyncResource = async (action, args) => {
-        if (args?.abort?.condition) {
-            args.abort.onAbort?.();
-            return args.fallbackResponse;
-        }
-        if (args?.beforeSend) {
-            const beforeSendResult = await new Promise((resolve) => {
-                let settled = false;
-                const settle = (value) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    resolve(value);
-                };
-                const next = () => settle('next');
-                const abort = () => settle('abort');
-                Promise.resolve(args.beforeSend({ next, abort }))
-                    .then(() => {
-                    settle('next');
-                })
-                    .catch((err) => {
-                    console.error('Error in beforeSend:', err);
-                    settle('abort');
-                });
-            });
-            if (beforeSendResult === 'abort') {
-                if (args?.reject) {
-                    throw {
-                        type: 'abort',
-                        message: 'Aborted in beforeSend',
-                        original: new Error('Aborted in beforeSend')
-                    };
-                }
-                return args.fallbackResponse;
-            }
-        }
-        const maxRetries = args?.maxRetries ?? 3;
-        let retries = 0;
-        const req = async (isRetry = false) => {
-            if (isRetry) {
-                retries++;
-                if (retries > maxRetries) {
-                    return Promise.reject(Error('Max retries reached'));
-                }
-            }
-            const response = await Promise.resolve(typeof action === 'function' ? action() : action);
-            await args?.onSuccess?.(response);
-            return response;
-        };
-        try {
-            return await req();
-        }
-        catch (err) {
-            let retryResult;
-            const retry = async () => await req(true)
-                .then((res) => (retryResult = res))
-                .catch(() => undefined);
-            const error = await errorParser(err, async () => await retry());
-            if (retryResult) {
-                return retryResult;
-            }
-            const { bus } = AppEvents();
-            bus.publish('OnAsyncHelperError', () => error);
-            await args?.onError?.(error);
-            if (args?.reject)
-                throw error;
-            return args?.fallbackResponse;
+        const result = await createAsyncAction(action, args);
+        if (!result.success && args?.reject) {
+            throw result.error;
         }
+        return result.response;
     };
     return {
         createAsyncAction,
-        createAsyncResource
+        createAsyncResource,
+        errorParser
     };
 };

package/dist/core/delivery/injectableDependencies/ErrorHandler.d.ts

@@ -1,21 +1,3 @@
-import { HttpServiceError } from '../../infra/httpService/index.js';
-import { SchemaFail, type RequestErrors } from '../schema/index.js';
-export type AppErrorType = 'http' | 'app' | 'schema' | 'abort';
-export interface AppError<T = unknown, CustomErrorField = never> {
-    type: AppErrorType;
-    message: string;
-    fields?: RequestErrors<T>;
-    status?: number;
-    original?: HttpServiceError<T> | SchemaFail<T> | Error;
-    custom?: CustomErrorField;
-    retry?: () => unknown;
-}
-export type ErrorType<T = unknown> = Error | HttpServiceError<T> | SchemaFail<T>;
-export declare const baseParseHttpError: <T = unknown, D = never>(error: HttpServiceError<T>, retry?: () => unknown | Promise<unknown>) => Promise<AppError<T, D>>;
-export declare const baseParseSchemaError: <SchemaData = unknown, D = never>(error: SchemaFail<SchemaData>, retry?: () => unknown | Promise<unknown>) => Promise<AppError<SchemaData, D>>;
-export declare const baseParseBaseError: <D = never>(error: Error, retry?: () => unknown | Promise<unknown>) => Promise<AppError<never, D>>;
-export declare const createErrorParser: <BaseError = unknown, Custom = unknown>(parsers?: {
-    parseBaseError?: typeof baseParseBaseError<Custom>;
-    parseHttpError?: typeof baseParseHttpError<BaseError, Custom>;
-    parseSchemaError?: typeof baseParseSchemaError<BaseError, Custom>;
-}) => (<T = unknown>(error: ErrorType<BaseError>, retry?: () => unknown | Promise<unknown>) => Promise<AppError<T, Custom>>);
+import { AppError, type IAppError } from '../../shared/appError/AppError.js';
+import type { AsyncHelperRetry } from './AsyncHelpers.js';
+export declare const createErrorHandler: <CustomData extends object>(handle?: <T = unknown>(error: AppError<T>, asyncHelperRetry: AsyncHelperRetry) => Promise<IAppError<T> & CustomData>) => <T = unknown>(error: Error, asyncHelperRetry?: AsyncHelperRetry) => Promise<IAppError<T> & CustomData>;

package/dist/core/delivery/injectableDependencies/ErrorHandler.js

@@ -1,45 +1,14 @@
-import { HttpServiceError } from '../../infra/httpService/index.js';
-import { SchemaFail } from '../schema/index.js';
-export const baseParseHttpError = async (error, retry) => {
-    const err = {
-        type: 'http',
-        message: error.message ?? 'unexpected error',
-        status: error.status ?? 500,
-        original: error,
-        retry
-    };
-    return { ...err, retry: undefined, original: undefined };
-};
-export const baseParseSchemaError = async (error, retry) => {
-    const err = {
-        type: 'schema',
-        message: 'schema validation error',
-        status: 422,
-        fields: error.getErrors(),
-        original: error,
-        retry
-    };
-    return { ...err, retry: undefined, original: undefined };
-};
-export const baseParseBaseError = async (error, retry) => {
-    const err = {
-        type: 'app',
-        message: error.message,
-        original: error,
-        retry
-    };
-    return { ...err, retry: undefined, original: undefined };
-};
-export const createErrorParser = (parsers) => {
-    return async (error, retry) => {
-        const { parseBaseError = baseParseBaseError, parseHttpError = baseParseHttpError, parseSchemaError = baseParseSchemaError } = parsers ?? {};
-        switch (true) {
-            case error instanceof HttpServiceError:
-                return (await parseHttpError(error, retry));
-            case error instanceof SchemaFail:
-                return (await parseSchemaError(error, retry));
-            default:
-                return (await parseBaseError(error, retry));
+import { AppError } from '../../shared/appError/AppError.js';
+export const createErrorHandler = (handle) => {
+    return async (error, asyncHelperRetry) => {
+        const appError = new AppError(error);
+        if (handle) {
+            const handled = await handle(appError, asyncHelperRetry ?? { can: false });
+            if (handled?.appErrorConvert) {
+                return handled;
+            }
+            throw new Error('Method "handle" must return result of "toPlainObject" method in AppError');
         }
+        return appError.toPlainObject();
     };
 };

package/dist/core/delivery/schema/Schema.d.ts

@@ -24,9 +24,16 @@ type ValidationErrors<Errors> = Errors extends ReadonlyArray<infer U> ? Validati
 } : ValidationMessage;
 export type RequestErrors<SchemaData> = Partial<ValidationErrors<SchemaData>>;
 export type RequestRules<SchemaData> = Partial<Record<DeepKeys<SchemaData>, ValidationRuleResult<SchemaData>[]>>;
-export declare class SchemaFail<SchemaData> {
+export interface ISchemaError<SchemaData> extends Error {
+    message: string;
+    data: RequestErrors<SchemaData>;
+}
+export declare class SchemaFail<SchemaData> extends Error implements ISchemaError<SchemaData> {
     private _errors;
+    data: RequestErrors<SchemaData>;
+    message: string;
     constructor(_errors: RequestErrors<SchemaData>);
+    getSelfTypedData<SelfTypedData = unknown>(): RequestErrors<SelfTypedData>;
     getErrors(): Partial<ValidationErrors<SchemaData>>;
 }
 interface SchemaBuilder<SchemaData, Rules = unknown, TransformResult = SchemaData, CustomMethods = unknown> {

package/dist/core/delivery/schema/Schema.js

@@ -1,8 +1,17 @@
 import { FormDataUtil } from '@azure-net/tools';
-export class SchemaFail {
+import { AzureNetKitInternalError } from '../../shared/appError/AppError.js';
+export class SchemaFail extends Error {
     _errors;
+    data;
+    message;
     constructor(_errors) {
+        super('Validation failed');
         this._errors = _errors;
+        this.message = 'Validation failed';
+        this.data = _errors;
+    }
+    getSelfTypedData() {
+        return this.data;
     }
     getErrors() {
         return this._errors;
@@ -67,7 +76,7 @@ class SchemaBuilderImpl {
                 let _errors = {};
                 let _isValid = true;
                 if (typeof _preparedData !== 'object') {
-                    throw Error('Data to validate is not an object');
+                    throw new AzureNetKitInternalError('[Schema] Data in "from" method can be only valid object or formData.');
                 }
                 const validated = (params) => {
                     _isValid = true;

package/dist/core/delivery.d.ts

@@ -0,0 +1,5 @@
+export { createPresenter, createStore, createPresenterFactory, createStoreFactory, clearCache } from '../edges/index.js';
+export { createAsyncHelpers, type AsyncHelperRetry, type AsyncResourceSettings, type AsyncActionResponse } from './delivery/injectableDependencies/AsyncHelpers.js';
+export { createErrorHandler } from './delivery/injectableDependencies/ErrorHandler.js';
+export { createSchemaFactory, schema, type Schema, type RequestErrors, type ISchemaError, type ValidationResult, type ValidationRuleResult, type ValidationParams } from './delivery/schema/Schema.js';
+export { createRules, validationMessagesRu, validationMessagesI18n, validationMessagesEn, type ValidationRuleParams } from './delivery/schema/rules/index.js';

package/dist/core/delivery.js

@@ -0,0 +1,5 @@
+export { createPresenter, createStore, createPresenterFactory, createStoreFactory, clearCache } from '../edges/index.js';
+export { createAsyncHelpers } from './delivery/injectableDependencies/AsyncHelpers.js';
+export { createErrorHandler } from './delivery/injectableDependencies/ErrorHandler.js';
+export { createSchemaFactory, schema } from './delivery/schema/Schema.js';
+export { createRules, validationMessagesRu, validationMessagesI18n, validationMessagesEn } from './delivery/schema/rules/index.js';

package/dist/core/errors.d.ts

@@ -0,0 +1,4 @@
+export { AppError, ErrorTypes, AzureNetKitInternalError, type IAppError } from './shared/appError/AppError.js';
+export { HttpServiceError } from './infra/httpService/HttpServiceInstance.js';
+export { AsyncHelperError } from './delivery/injectableDependencies/AsyncHelpers.js';
+export { SchemaFail } from './delivery/schema/Schema.js';

package/dist/core/errors.js

@@ -0,0 +1,4 @@
+export { AppError, ErrorTypes, AzureNetKitInternalError } from './shared/appError/AppError.js';
+export { HttpServiceError } from './infra/httpService/HttpServiceInstance.js';
+export { AsyncHelperError } from './delivery/injectableDependencies/AsyncHelpers.js';
+export { SchemaFail } from './delivery/schema/Schema.js';

package/dist/core/index.d.ts

@@ -1,8 +1,7 @@
-export * from './delivery/index.js';
-export * from './shared/middleware/index.js';
-export * from './shared/classMirror/index.js';
-export * from './shared/cookie/index.js';
-export * from './shared/boundaryProvider/index.js';
-export * from './shared/appEventBus/index.js';
-export * from './ui/index.js';
-export * from './svelte/index.js';
+export { event, stop, prevent, once, immediate, type EventHandler, onClickOutside, scrollTo, Mask, masked } from './ui/index.js';
+export { createQuery, createAsyncSignal, createActiveForm, refreshAsyncSignal, refreshAllAsyncSignals, type AsyncSignalOptions, type AsyncSignalSvelte, type QueryController, type CreateQueryOptions, type AsyncSignalSource, type AsyncStatus } from './svelte/index.js';
+export { createMiddlewareManager, type IMiddleware } from './shared/middleware/index.js';
+export { ClassMirror } from './shared/classMirror/index.js';
+export { UniversalCookie, type CookieOptions } from './shared/cookie/index.js';
+export { createBoundaryProvider, cleanupProvider, type ProviderSettings } from './shared/boundaryProvider/index.js';
+export { AppEvents } from './shared/appEventBus/index.js';

package/dist/core/index.js

@@ -1,8 +1,7 @@
-export * from './delivery/index.js';
-export * from './shared/middleware/index.js';
-export * from './shared/classMirror/index.js';
-export * from './shared/cookie/index.js';
-export * from './shared/boundaryProvider/index.js';
-export * from './shared/appEventBus/index.js';
-export * from './ui/index.js';
-export * from './svelte/index.js';
+export { event, stop, prevent, once, immediate, onClickOutside, scrollTo, Mask, masked } from './ui/index.js';
+export { createQuery, createAsyncSignal, createActiveForm, refreshAsyncSignal, refreshAllAsyncSignals } from './svelte/index.js';
+export { createMiddlewareManager } from './shared/middleware/index.js';
+export { ClassMirror } from './shared/classMirror/index.js';
+export { UniversalCookie } from './shared/cookie/index.js';
+export { createBoundaryProvider, cleanupProvider } from './shared/boundaryProvider/index.js';
+export { AppEvents } from './shared/appEventBus/index.js';

package/dist/core/infra/httpService/HttpServiceInstance.d.ts

@@ -17,8 +17,13 @@ export interface IHttpServiceResponse<T = unknown> {
     message: string;
     raw?: Response;
 }
-export interface IHttpServiceError<T = unknown> extends IHttpServiceResponse<T> {
+export interface IHttpServiceError<T = unknown> {
+    type: HttpErrorTypes;
+    response?: Response;
     original?: Error;
+    message: string;
+    status: number;
+    data?: T;
 }
 export declare class HttpServiceResponse<T> implements IHttpServiceResponse<T> {
     headers: Record<string, string>;
@@ -29,15 +34,18 @@ export declare class HttpServiceResponse<T> implements IHttpServiceResponse<T> {
     raw?: Response;
     constructor({ headers, status, success, data, message, raw }: IHttpServiceResponse<T>);
 }
-export declare class HttpServiceError<T> implements IHttpServiceError<T> {
-    headers: Record<string, string>;
+export declare enum HttpErrorTypes {
+    Internal = "internal",
+    External = "external"
+}
+export declare class HttpServiceError<T> extends Error implements IHttpServiceError<T> {
+    data?: T;
     status: number;
-    success: boolean;
-    data: T;
     message: string;
+    type: HttpErrorTypes;
     original?: Error;
-    raw?: Response;
-    constructor({ headers, status, success, data, message, original, raw }: IHttpServiceError<T>);
+    response?: Response;
+    constructor({ status, data, message, original, type, response }: Partial<IHttpServiceError<T>>);
 }
 export interface HttpInstanceNormalizedRequest {
     url: string | URL;
@@ -53,7 +61,7 @@ export interface HttpInstanceNormalizedRequest {
     requestInit: Omit<RequestInit, 'method' | 'headers' | 'body'>;
 }
 export type HttpInstanceOnRequest = (request: HttpInstanceNormalizedRequest) => void | Promise<void>;
-export type HttpInstanceOnError = (error: HttpServiceError<unknown>, request: HttpInstanceNormalizedRequest) => HttpServiceError<unknown> | Promise<HttpServiceError<unknown>>;
+export type HttpInstanceOnError = (error: HttpServiceError<unknown>, request: HttpInstanceNormalizedRequest) => void | Promise<void>;
 export type HttpInstanceDoFetch = <T = unknown>(request: HttpInstanceNormalizedRequest) => Promise<IHttpServiceResponse<T>>;
 export interface IHttpInstanceOptions extends Omit<RequestInit, 'headers' | 'method'> {
     headers?: NonNullable<RequestInit['headers']> | Record<string, string | undefined>;