@azure-net/kit 3.9.1 → 3.9.2

package/dist/core/infra/httpService/HttpServiceInstance.js

@@ -26,22 +26,26 @@ export class HttpServiceResponse {
         this.raw = raw;
     }
 }
-export class HttpServiceError {
-    headers;
-    status;
-    success;
+export var HttpErrorTypes;
+(function (HttpErrorTypes) {
+    HttpErrorTypes["Internal"] = "internal";
+    HttpErrorTypes["External"] = "external";
+})(HttpErrorTypes || (HttpErrorTypes = {}));
+export class HttpServiceError extends Error {
     data;
+    status;
     message;
+    type;
     original;
-    raw;
-    constructor({ headers, status, success, data, message, original, raw }) {
-        this.headers = headers;
+    response;
+    constructor({ status = 500, data, message = 'unknown error', original, type = HttpErrorTypes.Internal, response }) {
+        super(message);
         this.status = status;
-        this.success = success;
         this.data = data;
         this.message = message;
         this.original = original;
-        this.raw = raw;
+        this.response = response;
+        this.type = type;
     }
 }
 const stringifyJsonFunc = (data) => {
@@ -188,16 +192,39 @@ const withTimeout = (signal, timeout) => {
     };
 };
 const shouldRetryError = (error) => {
-    if (error instanceof HttpServiceError) {
-        return [408, 425, 429, 500, 502, 503, 504].includes(error.status);
-    }
-    return !(error instanceof Error && error.name === 'AbortError');
+    return error instanceof HttpServiceError && error.type === HttpErrorTypes.External;
 };
 const normalizeUnknownError = (error) => {
     if (error instanceof Error)
         return error;
     return new Error(String(error));
 };
+const parseResponse = async (response, request) => {
+    const raw = request.includeRaw && typeof response?.clone === 'function' ? response?.clone() : undefined;
+    let data;
+    let parseError;
+    try {
+        data = await parseBodyByFormat(response, request.responseFormat);
+    }
+    catch (error) {
+        parseError = normalizeUnknownError(error);
+        data = undefined;
+    }
+    if (!response.ok || parseError) {
+        const message = !response.ok
+            ? `Request failed with status code ${response.status}. ${response.statusText}`
+            : (parseError?.message ?? 'Internal error');
+        throw new HttpServiceError({
+            status: response.status,
+            data,
+            message,
+            type: !response.ok ? HttpErrorTypes.External : HttpErrorTypes.Internal,
+            original: parseError,
+            response: raw ?? response
+        });
+    }
+    return { data, headers: Object.fromEntries(response.headers.entries()), status: response.status, raw };
+};
 const defaultDoFetch = async (request) => {
     const maxAttempts = Math.max(1, Math.floor(request.retry) + 1);
     let lastError;
@@ -211,30 +238,14 @@ const defaultDoFetch = async (request) => {
                 body: request.body,
                 signal: timeoutState.signal ?? undefined
             });
-            const rawResponse = request.includeRaw ? response.clone() : undefined;
-            const data = await parseBodyByFormat(response, request.responseFormat);
-            if (!response.ok) {
-                const httpError = new HttpServiceError({
-                    headers: Object.fromEntries(response.headers.entries()),
-                    status: response.status,
-                    success: false,
-                    data,
-                    message: `Request failed with status code ${response.status}`,
-                    raw: rawResponse
-                });
-                lastError = httpError;
-                if (attempt >= maxAttempts || !shouldRetryError(httpError)) {
-                    throw httpError;
-                }
-                continue;
-            }
+            const { data, headers, status, raw } = await parseResponse(response, request);
             return new HttpServiceResponse({
-                headers: Object.fromEntries(response.headers.entries()),
-                status: response.status,
+                headers,
+                status,
                 success: true,
                 data,
                 message: 'Request completed',
-                raw: rawResponse
+                raw
             });
         }
         catch (error) {
@@ -303,28 +314,15 @@ const makeMethod = (method, defaults) => {
             const normalizedError = error instanceof HttpServiceError
                 ? error
                 : new HttpServiceError({
-                    headers: {},
-                    status: 500,
-                    success: false,
                     data: undefined,
-                    message: normalizeUnknownError(error).message,
+                    message: normalizeUnknownError(error).message ?? 'Unknown error',
                     original: normalizeUnknownError(error)
                 });
             const onError = options.onError ?? defaults.onError;
             if (!onError)
                 throw normalizedError;
-            const handledError = await onError(normalizedError, normalizedRequest);
-            if (!(handledError instanceof HttpServiceError)) {
-                throw new HttpServiceError({
-                    headers: normalizedError.headers,
-                    status: normalizedError.status,
-                    success: false,
-                    data: normalizedError.data,
-                    message: 'onError hook must return HttpServiceError',
-                    original: new Error(normalizedError.message)
-                });
-            }
-            throw handledError;
+            await onError(normalizedError, normalizedRequest);
+            throw normalizedError;
         }
     };
 };

package/dist/core/infra/query/QueryBuilder.js

@@ -1,3 +1,4 @@
+import { AzureNetKitInternalError } from '../../shared/appError/AppError.js';
 const normalizeSettings = (base, override) => {
     return {
         delimiter: override?.delimiter ?? base?.delimiter ?? true,
@@ -19,7 +20,7 @@ const encodeArrayEntries = (key, values, arrayFormat) => {
         case 'json':
             return [[key, JSON.stringify(cleanValues)]];
         default:
-            throw new Error(`Unsupported array format: ${arrayFormat}`);
+            throw new AzureNetKitInternalError(`[QueryInstance] Unsupported array format: ${arrayFormat}`);
     }
 };
 const serializeEntries = (obj, arrayFormat, objectFormat, prefix = '') => {

package/dist/core/infra/response/BaseResponse.js

@@ -1,3 +1,4 @@
+import { AzureNetKitInternalError } from '../../shared/appError/AppError.js';
 export class ResponseBuilder {
     response;
     state;
@@ -22,7 +23,7 @@ export class ResponseBuilder {
     }
     mapCollectionUsing(ResourceClass) {
         if (!Array.isArray(this.state.data)) {
-            throw new Error('toCollection can only be used when data is an array');
+            throw new AzureNetKitInternalError('[ResponseBuilder] Method "mapCollectionUsing" can only be used when data is an array');
         }
         const collection = this.state.data.map((dataElement) => new ResourceClass(dataElement).toPlainObject());
         const newResponse = new this.constructor(this.response);
@@ -40,7 +41,7 @@ export class ResponseBuilder {
                 result = result[key];
             }
             else {
-                throw new Error(`Path "${path}" not found in response data`);
+                throw new AzureNetKitInternalError(`[ResponseBuilder] Failed to extract: path "${path}" not found in response data`);
             }
         }
         const newResponse = new this.constructor(this.response);

package/dist/core/infra.d.ts

@@ -0,0 +1,6 @@
+export { createHttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, type IHttpServiceError, type IHttpServiceResponse, type IHttpServiceInstance, type IHttpInstanceOptions, type HttpInstanceNormalizedRequest, type HttpInstanceOnRequest, type HttpInstanceOnError, type HttpInstanceDoFetch, type HttpInstanceRequestMethod } from './infra/httpService/HttpServiceInstance.js';
+export { HttpStatusCode } from './infra/httpService/Statuses.js';
+export { BaseHttpDatasource, type CreateRequestCallbackType } from './infra/datasource/BaseDatasource.js';
+export { ResponseBuilder } from './infra/response/BaseResponse.js';
+export { createQueryInstance, type IQueryBuilderInstance, type ArrayFormat, type ObjectFormat, type IQueryBuilderSettings } from './infra/query/QueryBuilder.js';
+export { DTOMapper, type IDTOMapper } from './infra/resource/BaseResource.js';

package/dist/core/infra.js

@@ -0,0 +1,6 @@
+export { createHttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse } from './infra/httpService/HttpServiceInstance.js';
+export { HttpStatusCode } from './infra/httpService/Statuses.js';
+export { BaseHttpDatasource } from './infra/datasource/BaseDatasource.js';
+export { ResponseBuilder } from './infra/response/BaseResponse.js';
+export { createQueryInstance } from './infra/query/QueryBuilder.js';
+export { DTOMapper } from './infra/resource/BaseResource.js';

package/dist/core/shared/appError/AppError.d.ts

@@ -0,0 +1,30 @@
+import { HttpServiceError } from '../../infra/httpService/HttpServiceInstance.js';
+import { type RequestErrors } from '../../delivery/schema/Schema.js';
+export declare enum ErrorTypes {
+    Http = "Http",
+    Schema = "Schema",
+    KitInternalError = "AzureNetKitInternal",
+    AsyncHelperError = "AsyncHelperError",
+    Unknown = "Unknown"
+}
+export declare class AzureNetKitInternalError extends Error {
+}
+export interface IAppError<T = unknown> {
+    type: ErrorTypes;
+    message: string;
+    validation?: RequestErrors<T>;
+    external: boolean;
+    appErrorConvert?: boolean;
+}
+export declare class AppError<T = unknown> extends Error {
+    error: Error;
+    type: ErrorTypes;
+    message: string;
+    external: boolean;
+    validation?: RequestErrors<T>;
+    constructor(error: Error);
+    tryToGetExternalError<HttpServiceDataType = unknown>(): HttpServiceError<HttpServiceDataType> | undefined;
+    redeclareValidation<D = T>(validation: D): void;
+    toPlainObject<CustomData extends object>(custom?: CustomData): IAppError<T> & CustomData;
+    private parseError;
+}

package/dist/core/shared/appError/AppError.js

@@ -0,0 +1,66 @@
+import { HttpErrorTypes, HttpServiceError } from '../../infra/httpService/HttpServiceInstance.js';
+import { SchemaFail } from '../../delivery/schema/Schema.js';
+import { AsyncHelperError } from '../../delivery/injectableDependencies/AsyncHelpers.js';
+export var ErrorTypes;
+(function (ErrorTypes) {
+    ErrorTypes["Http"] = "Http";
+    ErrorTypes["Schema"] = "Schema";
+    ErrorTypes["KitInternalError"] = "AzureNetKitInternal";
+    ErrorTypes["AsyncHelperError"] = "AsyncHelperError";
+    ErrorTypes["Unknown"] = "Unknown";
+})(ErrorTypes || (ErrorTypes = {}));
+export class AzureNetKitInternalError extends Error {
+}
+export class AppError extends Error {
+    error;
+    type = ErrorTypes.Unknown;
+    message;
+    external = false;
+    validation;
+    constructor(error) {
+        super(error.message);
+        this.error = error;
+        this.message = error.message ?? 'Unknown error';
+        this.parseError();
+    }
+    tryToGetExternalError() {
+        if (this.external && this.error instanceof HttpServiceError) {
+            return this.error;
+        }
+        return undefined;
+    }
+    redeclareValidation(validation) {
+        this.validation = validation;
+    }
+    toPlainObject(custom) {
+        const customData = custom ?? {};
+        return {
+            message: this.message,
+            type: this.type,
+            external: this.external,
+            validation: this.validation,
+            appErrorConvert: true,
+            ...customData
+        };
+    }
+    parseError() {
+        switch (true) {
+            case this.error instanceof HttpServiceError:
+                this.type = ErrorTypes.Http;
+                this.external = this.error.type === HttpErrorTypes.External;
+                break;
+            case this.error instanceof SchemaFail:
+                this.type = ErrorTypes.Schema;
+                this.validation = this.error.getSelfTypedData();
+                break;
+            case this.error instanceof AzureNetKitInternalError:
+                this.type = ErrorTypes.KitInternalError;
+                break;
+            case this.error instanceof AsyncHelperError:
+                this.type = ErrorTypes.AsyncHelperError;
+                break;
+            default:
+                this.type = ErrorTypes.Unknown;
+        }
+    }
+}

package/dist/core/shared/appEventBus/EventBus.js

@@ -1,7 +1,7 @@
 import { EventBus } from '@azure-net/tools';
 import { createPresenter } from '@azure-net/edges';
 export const AppEvents = createPresenter(() => {
-    const appEventBus = new EventBus({ OnAsyncHelperError: [] });
+    const appEventBus = new EventBus({});
     return {
         bus: appEventBus
     };

package/dist/core/shared/boundaryProvider/Provider.js

@@ -1,5 +1,6 @@
 import { RequestContext } from '../../../edges/context/index.js';
 import { BROWSER } from '@azure-net/tools/environment';
+import { AzureNetKitInternalError } from '../appError/AppError.js';
 const clientCache = new Map();
 const factoriesCache = new WeakMap();
 const providerProxyCache = new Map();
@@ -94,15 +95,15 @@ export const createBoundaryProvider = (name, settings) => {
                 }
                 const factories = getFactories();
                 if (!(key in factories)) {
-                    throw new Error(`Service '${key}' not found in provider '${name}'`);
+                    throw new AzureNetKitInternalError(`[BoundaryProvider] Service '${key}' not found in provider '${name}'`);
                 }
                 const factory = factories[key];
                 if (typeof factory !== 'function') {
-                    throw Error('Factory must be a function');
+                    throw new AzureNetKitInternalError('[BoundaryProvider] Factory must be a function');
                 }
                 const instance = factory();
                 if (instance && typeof instance?.then === 'function') {
-                    throw new Error(`Service '${key}' in provider '${name}' returned Promise.`);
+                    throw new AzureNetKitInternalError(`[BoundaryProvider] Service '${key}' in provider '${name}' returned Promise.`);
                 }
                 cache.set(key, instance);
                 return instance;

package/dist/core/shared/classMirror/ClassMirror.d.ts

@@ -1,3 +1,8 @@
-export declare class ClassMirror<Target extends object> {
-    constructor(target: Target);
+declare const MIRROR_TARGET: unique symbol;
+declare const MIRROR_CACHE: unique symbol;
+export declare class ClassMirror {
+    private [MIRROR_TARGET];
+    private [MIRROR_CACHE];
+    constructor(target: object);
 }
+export {};

package/dist/core/shared/classMirror/ClassMirror.js

@@ -1,19 +1,38 @@
+const MIRROR_TARGET = Symbol('class-mirror-target');
+const MIRROR_CACHE = Symbol('class-mirror-cache');
 export class ClassMirror {
+    [MIRROR_TARGET];
+    [MIRROR_CACHE];
     constructor(target) {
-        const proto = Object.getPrototypeOf(target);
-        for (const name of Object.getOwnPropertyNames(proto)) {
-            if (name === 'constructor')
-                continue;
-            const descriptor = Object.getOwnPropertyDescriptor(proto, name);
-            if (!descriptor || typeof descriptor.value !== 'function')
-                continue;
-            if (name in this)
-                continue;
-            Object.defineProperty(this, name, {
-                value: descriptor.value.bind(target),
-                configurable: true,
-                writable: true
-            });
-        }
+        this[MIRROR_TARGET] = target;
+        this[MIRROR_CACHE] = new Map();
+        return new Proxy(this, {
+            get(proxyTarget, prop, receiver) {
+                if (Reflect.has(proxyTarget, prop)) {
+                    return Reflect.get(proxyTarget, prop, receiver);
+                }
+                const mirrorTarget = proxyTarget[MIRROR_TARGET];
+                const mirroredValue = Reflect.get(mirrorTarget, prop, mirrorTarget);
+                if (typeof mirroredValue !== 'function') {
+                    return mirroredValue;
+                }
+                const cache = proxyTarget[MIRROR_CACHE];
+                if (cache.has(prop)) {
+                    return cache.get(prop);
+                }
+                const bound = mirroredValue.bind(mirrorTarget);
+                cache.set(prop, bound);
+                return bound;
+            },
+            has(proxyTarget, prop) {
+                return Reflect.has(proxyTarget, prop) || Reflect.has(proxyTarget[MIRROR_TARGET], prop);
+            },
+            ownKeys(proxyTarget) {
+                return [...new Set([...Reflect.ownKeys(proxyTarget), ...Reflect.ownKeys(proxyTarget[MIRROR_TARGET])])];
+            },
+            getOwnPropertyDescriptor(proxyTarget, prop) {
+                return Reflect.getOwnPropertyDescriptor(proxyTarget, prop) ?? Reflect.getOwnPropertyDescriptor(proxyTarget[MIRROR_TARGET], prop);
+            }
+        });
     }
 }

package/dist/core/shared/cookie/UniversalCookie.js

@@ -1,4 +1,5 @@
-import { Cookies, EnvironmentUtil } from '@azure-net/tools';
+import { Cookies } from '@azure-net/tools';
+import { BROWSER } from '@azure-net/tools/environment';
 import { RequestContext } from '@azure-net/edges/context';
 /**
  * Utility class for managing cookies in svelte ssr (browser and server).
@@ -17,11 +18,11 @@ export class UniversalCookie {
      * @returns {void}
      */
     static set(name, value, options) {
-        if (EnvironmentUtil.isBrowser) {
+        if (BROWSER) {
             Cookies.set(name, value, options);
             return;
         }
-        if (EnvironmentUtil.isServer) {
+        else {
             const event = RequestContext.current().event;
             if (event) {
                 const encodedKey = encodeURIComponent(name);
@@ -53,7 +54,6 @@ export class UniversalCookie {
                 return;
             }
         }
-        throw new Error('Could not detect current environment');
     }
     /**
      * Retrieves the value of a cookie by key.
@@ -64,10 +64,10 @@ export class UniversalCookie {
      * @returns {T | undefined} The cookie value, parsed as type T or null if not found.
      */
     static get(name) {
-        if (EnvironmentUtil.isBrowser) {
+        if (BROWSER) {
             return Cookies.get(name) ?? undefined;
         }
-        if (EnvironmentUtil.isServer) {
+        else {
             const event = RequestContext.current().event;
             if (event) {
                 const encodedKey = encodeURIComponent(name);
@@ -85,7 +85,6 @@ export class UniversalCookie {
             }
             return undefined;
         }
-        return undefined;
     }
     /**
      * Retrieves all cookies as a key-value record.
@@ -95,10 +94,10 @@ export class UniversalCookie {
      * @returns {T | undefined} An object with all cookie keys and their values.
      */
     static getAll() {
-        if (EnvironmentUtil.isBrowser) {
+        if (BROWSER) {
             return Cookies.getAll();
         }
-        if (EnvironmentUtil.isServer) {
+        else {
             const event = RequestContext.current().event;
             const result = {};
             if (event) {
@@ -114,7 +113,6 @@ export class UniversalCookie {
             }
             return result;
         }
-        return undefined;
     }
     /**
      * Checks if a cookie with the given key exists.

package/dist/core/svelte/ActiveForm/ActiveForm.svelte.d.ts

@@ -1,6 +1,6 @@
 import type { RequestErrors } from '../../delivery/schema/index.js';
-import type { AsyncActionResponse } from '../../index.js';
-type InitialData<FormData, Initial extends Partial<FormData>> = Initial | Promise<Initial> | (() => Initial | Promise<Initial>);
+import type { AsyncActionResponse } from '../../delivery/injectableDependencies/AsyncHelpers.js';
+type InitialData<FormData, Initial extends Partial<FormData>> = () => Initial | Promise<Initial>;
 type PathRequiredShape<T, P extends string> = P extends `${infer Head}.${infer Tail}` ? Head extends keyof T ? {
     [K in Head]-?: PathRequiredShape<NonNullable<T[K]>, Tail>;
 } : unknown : P extends keyof T ? {
@@ -8,6 +8,7 @@ type PathRequiredShape<T, P extends string> = P extends `${infer Head}.${infer T
 } : unknown;
 type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
 type RequiredByPaths<T, P extends string> = [P] extends [never] ? object : UnionToIntersection<PathRequiredShape<T, P>>;
+type ResetBehaviors = 'clear' | 'initial' | 'reloadInitial' | 'default';
 export interface FormConfig<FormData, Response, Initial extends Partial<FormData> = Partial<FormData>, RequiredPath extends string = never> {
     initialData?: InitialData<FormData, Initial>;
     required?: readonly RequiredPath[];
@@ -17,13 +18,13 @@ export interface FormConfig<FormData, Response, Initial extends Partial<FormData
         form: ActiveFormController<FormData, RequiredPath>;
         abort: () => void;
     }) => Promise<void> | void;
-    waitForInitialData?: boolean;
+    successBehavior?: ResetBehaviors;
 }
 export interface ActiveForm<FormData, Response, Custom, RequiredPath extends string = never> {
     data: Partial<FormData> & RequiredByPaths<FormData, RequiredPath>;
     errors: RequestErrors<FormData>;
     submit: () => Promise<AsyncActionResponse<Response, FormData, Custom>>;
-    reset: (toInitial?: boolean) => void;
+    reset: (behavior?: ResetBehaviors) => Promise<void>;
     pending: boolean;
     dirty: boolean;
     ready: Promise<Partial<FormData>>;
@@ -31,7 +32,7 @@ export interface ActiveForm<FormData, Response, Custom, RequiredPath extends str
 export interface ActiveFormController<FormData, RequiredPath extends string = never> {
     data: Partial<FormData> & RequiredByPaths<FormData, RequiredPath>;
     errors: RequestErrors<FormData>;
-    reset: (toInitial?: boolean) => void;
+    reset: (behavior?: ResetBehaviors) => Promise<void>;
 }
 type ExtractResponse<T> = T extends AsyncActionResponse<infer R, unknown, unknown> ? R : never;
 type ExtractFormData<T> = T extends AsyncActionResponse<unknown, infer D, unknown> ? D : never;

package/dist/core/svelte/ActiveForm/ActiveForm.svelte.js

@@ -3,32 +3,27 @@ export const createActiveForm = (onSubmit, config) => {
     const isPromise = (value) => {
         return typeof value?.then === 'function';
     };
-    const resolveInitialSource = () => {
-        const source = config?.initialData;
-        if (!source) {
-            return { sync: true, value: {} };
-        }
-        const result = typeof source === 'function' ? source() : source;
-        if (isPromise(result)) {
-            return { sync: false, promise: result };
-        }
-        return { sync: true, value: (result ?? {}) };
-    };
-    const initialSource = resolveInitialSource();
-    let initial = initialSource.sync ? initialSource.value : {};
+    let initial = {};
     let formData = $state(ObjectUtil.deepClone(initial));
     let formErrors = $state({});
     let pending = $state(false);
     const dirty = $derived(!ObjectUtil.equals(formData, initial));
-    const ready = (async () => {
-        if (!initialSource.sync) {
-            initial = (await initialSource.promise) ?? {};
-            if (config?.waitForInitialData !== false) {
-                formData = ObjectUtil.deepClone(initial);
-            }
+    const loadInitialData = async () => {
+        const source = config?.initialData;
+        if (!source) {
+            initial = {};
+            formData = ObjectUtil.deepClone(initial);
+            formErrors = {};
+            return initial;
         }
+        const value = source();
+        const nextInitial = isPromise(value) ? await value : value;
+        initial = (nextInitial ?? {});
+        formData = ObjectUtil.deepClone(initial);
+        formErrors = {};
         return initial;
-    })();
+    };
+    const ready = loadInitialData();
     const submit = async () => {
         pending = true;
         try {
@@ -49,11 +44,11 @@ export const createActiveForm = (onSubmit, config) => {
             const result = await onSubmit($state.snapshot(formData));
             if (result.success) {
                 await config?.onSuccess?.(result.response);
-                formErrors = {};
+                await reset(config?.successBehavior ?? 'default');
             }
             else {
-                if (result.error?.fields) {
-                    formErrors = result.error.fields;
+                if (result.error?.validation) {
+                    formErrors = result.error.validation;
                 }
                 await config?.onError?.();
             }
@@ -63,8 +58,18 @@ export const createActiveForm = (onSubmit, config) => {
             pending = false;
         }
     };
-    const reset = (toInitial = false) => {
-        formData = toInitial ? ObjectUtil.deepClone(initial) : {};
+    const reset = async (behavior = 'clear') => {
+        switch (behavior) {
+            case 'clear':
+                formData = {};
+                break;
+            case 'initial':
+                formData = ObjectUtil.deepClone(initial);
+                break;
+            case 'reloadInitial':
+                await loadInitialData();
+                break;
+        }
         formErrors = {};
     };
     const formApi = {
@@ -101,8 +106,8 @@ export const createActiveForm = (onSubmit, config) => {
         get pending() {
             return pending;
         },
-        ready,
         submit,
+        ready,
         reset
     };
 };

package/dist/core/svelte/AsyncSignal/AsyncSignal.svelte.d.ts

@@ -3,7 +3,6 @@ export type AsyncSignalSource = 'auto' | 'manual' | 'global';
 export interface AsyncSignalOptions<TData, TError = Error> {
     server?: boolean;
     immediate?: boolean;
-    watch?: (() => unknown)[];
     initialData?: TData | (() => TData);
     beforeSend?: (meta: {
         initial: boolean;