@optionfactory/ful 6.0.8 → 7.0.1

package/dist/ful.d.mts

@@ -0,0 +1,941 @@
+export type Problem = {
+    type: string;
+    context: string | null;
+    reason: string;
+    details: any | null;
+};
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export type HttpInterceptor = {
+    intercept: (arg0: URL, arg1: RequestInit | undefined, arg2: HttpInterceptorChain) => Promise<Response>;
+};
+export type AsyncExtension = {
+    promises: Promise<any>[];
+};
+export type AsyncEvent = Event & {
+    async?: AsyncExtension;
+};
+/**
+ * @typedef {Object} AsyncExtension
+ * @property {Promise<any>[]} promises
+ * @typedef {Event & { async?: AsyncExtension }} AsyncEvent
+ */
+export class AsyncEvents {
+    /**
+     * Dispatches an event and handles asynchronous resolution based on the execution mode.
+     * @param {HTMLElement} el - The target element dispatching the event.
+     * @param {AsyncEvent} evt - The event instance.
+     * @param {{mode?: 'broadcast' | 'pipeline' | 'delegate'}} [options] - Configuration options (defaults to 'broadcast').
+     * @returns {Promise<any>} Resolves with an array of values for broadcasts, a single value for pipelines/delegates, or undefined.
+     */
+    static fireAsync(el: HTMLElement, evt: AsyncEvent, options?: {
+        mode?: "broadcast" | "pipeline" | "delegate";
+    }): Promise<any>;
+    /**
+     * Registers an asynchronous event listener wrapper.
+     * @param {HTMLElement} el - The target element.
+     * @param {string} type - The event name/type.
+     * @param {Function} fn - The async listener middleware function returning the execution result.
+     * @param {AddEventListenerOptions} [options] - Native addEventListener options.
+     * @returns {EventListener} The underlying proxy listener function needed for cleanup via asyncOff.
+     */
+    static asyncOn(el: HTMLElement, type: string, fn: Function, options?: AddEventListenerOptions): EventListener;
+    /**
+     * Unregisters an asynchronous event listener proxy.
+     * @param {HTMLElement} el - The target element.
+     * @param {string} type - The event name/type.
+     * @param {EventListener} listener - The proxy listener instance previously returned by asyncOn.
+     * @param {EventListenerOptions} [options] - Native removeEventListener options.
+     */
+    static asyncOff(el: HTMLElement, type: string, listener: EventListener, options?: EventListenerOptions): void;
+    /**
+     * Mixes the asynchronous execution engine extensions into target class prototypes.
+     * @param {...Function} classes - The target class constructors to decorate.
+     */
+    static mixInto(...classes: Function[]): void;
+}
+export class AuthorizationCodeFlow {
+    static forKeycloak(clientId: any, realmBaseUrl: any, redirectUri: any, maybeScope: any): AuthorizationCodeFlow;
+    constructor(clientId: any, scope: any, { auth, token, registration, logout, redirect }: {
+        auth: any;
+        token: any;
+        registration: any;
+        logout: any;
+        redirect: any;
+    });
+    clientId: any;
+    scope: any;
+    uri: {
+        auth: any;
+        token: any;
+        registration: any;
+        logout: any;
+        redirect: any;
+    };
+    action(uri: any, additionalParams: any): Promise<void>;
+    registration(additionalParams: any): Promise<void>;
+    applicationInitiatedAction(kcAction: any, additionalParams: any): Promise<void>;
+    ensureLoggedIn(): Promise<AuthorizationCodeFlowSession | null>;
+    #private;
+}
+export namespace AuthorizationCodeFlow {
+    let PKCE_AND_STATE_KEY: string;
+}
+export class AuthorizationCodeFlowInterceptor {
+    constructor(session: any, gracePeriodBefore: any, gracePeriodAfter: any);
+    intercept(url: any, request: any, chain: any): Promise<any>;
+    #private;
+}
+export class AuthorizationCodeFlowSession {
+    static parseToken(token: any): {
+        header: any;
+        payload: any;
+        signature: any;
+    };
+    constructor(clientId: any, t: any, { token, logout, redirect }: {
+        token: any;
+        logout: any;
+        redirect: any;
+    });
+    clientId: any;
+    token: any;
+    idToken: {
+        header: any;
+        payload: any;
+        signature: any;
+    };
+    accessToken: {
+        header: any;
+        payload: any;
+        signature: any;
+    };
+    refreshToken: {
+        header: any;
+        payload: any;
+        signature: any;
+    };
+    uri: {
+        token: any;
+        logout: any;
+        redirect: any;
+    };
+    refreshCallback: any;
+    onRefresh(callback: any): void;
+    refresh(): Promise<void>;
+    shouldBeRefreshed(gracePeriod: any): boolean;
+    refreshIf(gracePeriod: any): Promise<void>;
+    logout(): void;
+    bearerToken(): string;
+    interceptor(gracePeriodBefore: any, gracePeriodAfter: any): AuthorizationCodeFlowInterceptor;
+}
+export class Base64 {
+    static encode(arrayBuffer: any, dialect: any): string;
+    static decode(str: any, dialect: any): ArrayBuffer;
+}
+export namespace Base64 {
+    let STANDARD: string;
+    let URL_SAFE: string;
+}
+export class Bindings {
+    /**
+     * @param {{ [x: string]: any; }} obj
+     * @param {string} prefix
+     * @param {Set<String>} stops
+     * @return {{ [x: string]: any; }}
+     */
+    static flatten(obj: {
+        [x: string]: any;
+    }, prefix: string, stops: Set<string>): {
+        [x: string]: any;
+    };
+    /**
+     * @param {any} result
+     * @param {string} path
+     * @param {any} value
+     */
+    static providePath(result: any, path: string, value: any): any;
+    /**
+     *
+     * @param {Element & {dataset?: any} & {checked?: boolean} & {value?: any}} el
+     * @returns
+     */
+    static extract(el: Element & {
+        dataset?: any;
+    } & {
+        checked?: boolean;
+    } & {
+        value?: any;
+    }): any;
+    /**
+     *
+     * @param {HTMLFormElement} form
+     * @param {HTMLElement} [submitter]
+     * @returns
+     */
+    static extractFrom(form: HTMLFormElement, submitter?: HTMLElement): {};
+    /**
+     *
+     * @param {Element  & {checked?: boolean} & {value?: any}} el
+     * @returns
+     */
+    static mutate(el: Element & {
+        checked?: boolean;
+    } & {
+        value?: any;
+    }, raw: any): void;
+    static mutateIn(form: any, values: any): void;
+    static errors(form: any, es: any, scrollOnError: any): void;
+}
+export class Checkbox extends ParsedElement {
+    static observed: string[];
+    static slots: boolean;
+    static template: string;
+    static formAssociated: boolean;
+    internals: ElementInternals;
+    render({ slots, observed, disabled }: {
+        slots: any;
+        observed: any;
+        disabled: any;
+    }): void;
+    set disabled(d: any);
+    get disabled(): any;
+    set readonly(v: any);
+    get readonly(): any;
+    set required(d: boolean);
+    get required(): boolean;
+    set value(value: any);
+    get value(): any;
+    focus(options: any): void;
+    setCustomValidity(error: any): void;
+    #private;
+}
+export class Dropdown extends ParsedElement {
+    static slots: boolean;
+    static template: string;
+    static templates: {
+        options: string;
+    };
+    render({ slots }: {
+        slots: any;
+    }): void;
+    acceptSelection(): void;
+    update(values: any): void;
+    hide(): void;
+    get shown(): boolean;
+    show(loader: any): Promise<void>;
+    moveOrShow(forward: any, loader: any): Promise<void>;
+    #private;
+}
+/**
+ * @typedef {{ type: string; context: string?; reason: string; details: any?; }} Problem
+ */
+export class Failure extends Error {
+    static dropProblemsContext(problems: any, prefix: any): any;
+    /**
+     *
+     * @param {string} message
+     * @param {Problem[]} problems
+     * @param {*} cause
+     */
+    constructor(message: string, problems: Problem[], cause: any);
+    problems: Problem[];
+    dropping(prefix: any): Failure;
+}
+export class Form extends ParsedElement {
+    form: any;
+    render(): void;
+    /**
+     *
+     * @param {HTMLElement} [submitter]
+     * @returns
+     */
+    submit(submitter?: HTMLElement): Promise<void>;
+    set errors(es: any);
+    reset(): void;
+    spinner(spin: any): void;
+    set values(vs: {});
+    get values(): {};
+}
+export class FormLoader {
+    static create(el: any, conf: any): RemoteJsonFormLoader | LocalFormLoader;
+}
+export class Hex {
+    static decode(hex: any): Uint8Array<ArrayBuffer>;
+    static encode(bytes: any, upper: any): string;
+}
+export class HttpClient {
+    /**
+     * Creates a builder for an HttpClient.
+     * @returns {HttpClientBuilder} the client builder
+     */
+    static builder(): HttpClientBuilder;
+    /**
+     * Creates an HttpClient.
+     * @param {HttpInterceptor[]|undefined} interceptors - a list of interceptors to be registered for every request performed by the created client.
+     */
+    constructor(interceptors: HttpInterceptor[] | undefined);
+    /**
+     * Performs an HTTP exchange.
+     * @async
+     * @param {string} uri - the (possibly relative) request url
+     * @param {RequestInit|undefined} options - fetch options
+     * @param {HttpInterceptor[]|undefined} interceptors - the HttpInterceptors to be registered for this exchange.
+     * @returns {Promise<Response>} the response
+     */
+    exchange(uri: string, options: RequestInit | undefined, interceptors: HttpInterceptor[] | undefined): Promise<Response>;
+    /**
+     * Creates a request builder.
+     * @param {string} method - the HTTP method to be used
+     * @param {string} uri - the (possibly relative) request url
+     * @returns {HttpRequestBuilder} the request builder
+     */
+    request(method: string, uri: string): HttpRequestBuilder;
+    /**
+     * Creates a request builder.
+     * @param {string} uri - the (possibly relative) request url
+     * @returns {HttpRequestBuilder} the request builder
+     */
+    get(uri: string): HttpRequestBuilder;
+    /**
+     * Creates a request builder.
+     * @param {string} uri - the (possibly relative) request url
+     * @returns {HttpRequestBuilder} the request builder
+     */
+    head(uri: string): HttpRequestBuilder;
+    /**
+     * Creates a request builder.
+     * @param {string} uri - the (possibly relative) request url
+     * @returns {HttpRequestBuilder} the request builder
+     */
+    post(uri: string): HttpRequestBuilder;
+    /**
+     * Creates a request builder.
+     * @param {string} uri - the (possibly relative) request url
+     * @returns {HttpRequestBuilder} the request builder
+     */
+    put(uri: string): HttpRequestBuilder;
+    /**
+     * Creates a request builder.
+     * @param {string} uri - the (possibly relative) request url
+     * @returns {HttpRequestBuilder} the request builder
+     */
+    patch(uri: string): HttpRequestBuilder;
+    /**
+     * Creates a request builder.
+     * @param {string} uri - the (possibly relative) request url
+     * @returns {HttpRequestBuilder} the request builder
+     */
+    delete(uri: string): HttpRequestBuilder;
+    #private;
+}
+/**
+ * @typedef {Int8Array| Uint8Array| Uint8ClampedArray| Int16Array| Uint16Array| Int32Array| Uint32Array| Float32Array| Float64Array| BigInt64Array| BigUint64Array} TypedArray
+ */
+/**
+ * @typedef HttpInterceptor
+ * @property {function(URL,RequestInit|undefined,HttpInterceptorChain):Promise<Response>} intercept
+ */
+export class HttpClientError extends Failure {
+    /**
+     *
+     * @param {string} type
+     * @param {any} cause
+     * @returns
+     */
+    static of(type: string, cause: any): HttpClientError;
+    /**
+     * Creates an HttpClientError from a Response.
+     * @param {Response} response
+     * @returns an HttpClientError
+     */
+    static fromResponse(response: Response): Promise<HttpClientError>;
+    /**
+     * @param {string} message
+     * @param {number} status
+     * @param {{ type: string; context: string?; reason: string; details: any?; }[]} problems
+     * @param {Error|undefined} [cause]
+     */
+    constructor(message: string, status: number, problems: {
+        type: string;
+        context: string | null;
+        reason: string;
+        details: any | null;
+    }[], cause?: Error | undefined);
+    status: number;
+    dropping(prefix: any): HttpClientError;
+}
+export class Input extends ParsedElement {
+    static observed: string[];
+    static slots: boolean;
+    static template: string;
+    static formAssociated: boolean;
+    _input: any;
+    _fieldError: any;
+    internals: ElementInternals;
+    _type(): string;
+    _fragment(type: any, slots: any): any;
+    render({ slots, observed, disabled, skipObservedSetup }: {
+        slots: any;
+        observed: any;
+        disabled: any;
+        skipObservedSetup: any;
+    }): void;
+    set disabled(d: any);
+    get disabled(): any;
+    set readonly(v: any);
+    get readonly(): any;
+    set required(d: boolean);
+    get required(): boolean;
+    set value(value: any);
+    get value(): any;
+    focus(options: any): void;
+    setCustomValidity(error: any): void;
+    formResetCallback(): void;
+}
+export class InputFile extends Input {
+    static l10n: {
+        en: {
+            dropzonelabel: string;
+            unaccepptablefiletype: string;
+            maxfilesizeexceeded: string;
+            maxtotalsizeexceeded: string;
+            maxfilesexceeded: string;
+        };
+        it: {
+            dropzonelabel: string;
+            unaccepptablefiletype: string;
+            maxfilesizeexceeded: string;
+            maxtotalsizeexceeded: string;
+            maxfilesexceeded: string;
+        };
+    };
+    static templates: {
+        items: string;
+        warning: string;
+    };
+    render(conf: any): void;
+    set accept(vs: any);
+    get accept(): any;
+    set multiple(v: any);
+    get multiple(): any;
+    set itemlist(v: any);
+    get itemlist(): any;
+    set dropzone(v: any);
+    get dropzone(): any;
+    set maxfiles(v: any);
+    get maxfiles(): any;
+    set maxfilesize(v: any);
+    get maxfilesize(): any;
+    set maxtotalsize(v: any);
+    get maxtotalsize(): any;
+    set files(vs: any);
+    get files(): any;
+    warning(key: any, args: any): void;
+    set file(v: any);
+    get file(): any;
+    get totalsize(): any;
+    #private;
+}
+export class InputInstant extends Input {
+    render(conf: any): void;
+    set min(v: string | null);
+    get min(): string | null;
+    set max(v: string | null);
+    get max(): string | null;
+    set step(v: any);
+    get step(): any;
+    set value(v: string | null);
+    get value(): string | null;
+}
+export class InputLocalDate extends Input {
+    static #fromIsoOrOffset(v: any): any;
+    render(conf: any): void;
+    set min(v: any);
+    get min(): any;
+    set max(v: any);
+    get max(): any;
+    set step(v: any);
+    get step(): any;
+}
+export class InputLocalTime extends InputLocalDate {
+}
+export class Instant extends ParsedElement {
+    static isoToLocal(iso: any): string;
+    render(): void;
+}
+export class InstantFilter extends Input {
+    render(conf: any): void;
+    set value(v: any[] | undefined);
+    get value(): any[] | undefined;
+    #private;
+}
+export class LocalDate extends ParsedElement {
+    render(): void;
+}
+export class LocalDateFilter extends Input {
+    render(conf: any): void;
+    set value(v: any[] | undefined);
+    get value(): any[] | undefined;
+    #private;
+}
+export class LocalStorage extends Storage {
+    static save(k: any, v: any): void;
+    static load(k: any): any;
+    static remove(k: any): void;
+    static pop(k: any): any;
+}
+export class LocalizationModule {
+    static t(k: any, ...args: any[]): any;
+    static tl(k: any, args: any): any;
+}
+export class MediaType {
+    /**
+     *
+     * @param {string|null|undefined} v
+     * @returns
+     */
+    static parse(v: string | null | undefined): MediaType;
+    constructor(type: any, subtype: any);
+    get normalized(): string;
+    get type(): any;
+    get subtype(): any;
+    #private;
+}
+export class Pagination extends ParsedElement {
+    static observed: string[];
+    static l10n: {
+        en: {
+            showing: string;
+            navigation: string;
+            previous: string;
+            next: string;
+        };
+        it: {
+            showing: string;
+            navigation: string;
+            previous: string;
+            next: string;
+        };
+    };
+    static config: {
+        prevIcon: string;
+        nextIcon: string;
+        reloadIcon: string;
+    };
+    static template: string;
+    render({ observed }: {
+        observed: any;
+    }): void;
+    update(current: any, total: any): void;
+    set total(value: number);
+    get total(): number;
+    set current(value: number);
+    get current(): number;
+    #private;
+}
+export class Plugin {
+    configure(registry: any): void;
+}
+export class RadioGroup extends ParsedElement {
+    static observed: string[];
+    static slots: boolean;
+    static template: string;
+    static formAssociated: boolean;
+    internals: ElementInternals;
+    render({ slots, observed, disabled }: {
+        slots: any;
+        observed: any;
+        disabled: any;
+    }): void;
+    set disabled(d: any);
+    get disabled(): any;
+    set readonly(v: any);
+    get readonly(): any;
+    set required(d: boolean);
+    get required(): boolean;
+    set value(value: string | boolean | null);
+    get value(): string | boolean | null;
+    focus(options: any): void;
+    setCustomValidity(error: any): void;
+    #private;
+}
+export class Select extends ParsedElement {
+    static observed: string[];
+    static slots: boolean;
+    static template: string;
+    static templates: {
+        items: string;
+    };
+    static formAssociated: boolean;
+    internals: ElementInternals;
+    render({ slots, observed, disabled }: {
+        slots: any;
+        observed: any;
+        disabled: any;
+    }): Promise<void>;
+    set value(vs: any);
+    get value(): any;
+    set disabled(d: any);
+    get disabled(): any;
+    set readonly(v: any);
+    get readonly(): any;
+    set required(d: boolean);
+    get required(): boolean;
+    set itemlist(v: any);
+    get itemlist(): any;
+    withLoader(fn: any): Promise<any>;
+    get entry(): [any, any] | [any, any][];
+    focus(options: any): void;
+    setCustomValidity(error: any): void;
+    #private;
+}
+export class SelectLoader {
+    static create(el: any, conf: any): RemoteLoader | PartialRemoteLoader | InMemoryLoader;
+    static #responseMapperFrom(el: any): any;
+}
+export class SessionStorage extends Storage {
+    static save(k: any, v: any): void;
+    static load(k: any): any;
+    static remove(k: any): void;
+    static pop(k: any): any;
+}
+export class SortButton extends ParsedElement {
+    static observed: string[];
+    render(): void;
+    set order(value: any);
+    get order(): any;
+    #private;
+}
+export class Spinner extends ParsedElement {
+    static slots: boolean;
+    static template: string;
+    render({ slots }: {
+        slots: any;
+    }): void;
+}
+export class Table extends ParsedElement {
+    static slots: boolean;
+    static l10n: {
+        en: {
+            initial: string;
+            error: string;
+            nodata: string;
+        };
+        it: {
+            initial: string;
+            error: string;
+            nodata: string;
+        };
+    };
+    static config: {
+        searchIcon: string;
+    };
+    static template: string;
+    static templates: {
+        row: string;
+    };
+    render({ slots, observed }: {
+        slots: any;
+        observed: any;
+    }): Promise<void>;
+    reload(): Promise<void>;
+    load(pageRequest: any, sortRequest: any, filterRequest: any): Promise<void>;
+    withLoader(fn: any): Promise<any>;
+    resetWithFilter(filterRequest: any): Promise<void>;
+    #private;
+}
+export class TableSchemaParser {
+    static parse(nodeOrFragment: any, template: any): {
+        headersTemplate: any;
+        rowsTemplate: any;
+        sort: {
+            sorter: string | null;
+            order: string | null;
+        };
+        length: number;
+    };
+}
+export class TextFilter extends Input {
+    render(conf: any): void;
+    set value(v: any[] | undefined);
+    get value(): any[] | undefined;
+    #private;
+}
+export class Timing {
+    static sleep(ms: any): Promise<any>;
+    static DEBOUNCE_DEFAULT: number;
+    static DEBOUNCE_IMMEDIATE: number;
+    /**
+     * Executes only after a period of inactivity (pause in events).
+     * Respond to the "end" of a series of events.
+     * @param {*} timeoutMs
+     * @param {*} func
+     * @param {*} [options]
+     * @returns {[function, function]}
+     */
+    static debounce(timeoutMs: any, func: any, options?: any): [Function, Function];
+    static THROTTLE_DEFAULT: number;
+    static THROTTLE_NO_LEADING: number;
+    static THROTTLE_NO_TRAILING: number;
+    /**
+     * Executes at most once per specified time interval, regardless of ongoing events.
+     * @param {*} timeoutMs
+     * @param {*} func
+     * @param {*} [options]
+     * @returns {[function, function]}
+     */
+    static throttle(timeoutMs: any, func: any, options?: any): [Function, Function];
+}
+export class VersionedLocalStorage {
+    static save(key: any, revision: any, data: any): void;
+    static load(key: any, revision: any): any;
+}
+export class VersionedSessionStorage {
+    static save(key: any, revision: any, data: any): void;
+    static load(key: any, revision: any): any;
+}
+declare class HttpInterceptorChain {
+    /**
+     *
+     * @param {HttpInterceptor[]} interceptors
+     * @param {number} current
+     */
+    constructor(interceptors: HttpInterceptor[], current: number);
+    /**
+     *
+     * @param {URL} url
+     * @param {RequestInit} request
+     * @returns {Promise<Response>} the response
+     */
+    proceed(url: URL, request: RequestInit): Promise<Response>;
+    #private;
+}
+import { ParsedElement } from '@optionfactory/ftl';
+declare class RemoteJsonFormLoader {
+    constructor(http: any, url: any, method: any, requestMapper: any, responseMapper: any);
+    prepare(values: any, form: any): any;
+    submit(values: any, form: any): Promise<any>;
+    transform(response: any, form: any): any;
+    #private;
+}
+declare class LocalFormLoader {
+    constructor(requestMapper: any, responseMapper: any);
+    prepare(values: any, form: any): Promise<any>;
+    submit(values: any, form: any, response: any): Promise<any>;
+    transform(response: any, form: any): Promise<any>;
+    #private;
+}
+declare class HttpRequestBuilder {
+    /**
+     * Creates an HttpRequestBuilder.
+     * @param {HttpClient} client
+     * @param {string} method - the HTTP method to be used
+     * @param {string} uri - the (possibly relative) request url
+     * @returns {HttpRequestBuilder} the builder
+     */
+    static create(client: HttpClient, method: string, uri: string): HttpRequestBuilder;
+    /**
+     * Creates an HttpRequestBuilder.
+     * @param {HttpClient} client
+     * @param {string} method - the HTTP method to be used
+     * @param {string} uri - the (possibly relative) request url
+     * @param {URLSearchParams} params
+     * @param {Headers} headers
+     * @param {any} body
+     * @param {Omit<RequestInit,"headers"|"method"|"body">} options
+     * @param {HttpInterceptor[]} interceptors
+     */
+    constructor(client: HttpClient, method: string, uri: string, params: URLSearchParams, headers: Headers, body: any, options: Omit<RequestInit, "headers" | "method" | "body">, interceptors: HttpInterceptor[]);
+    /**
+     * Add all passed headers to the request, overriding existing ones if that key already exists. Null and undefined values cause the key to be removed.
+     * @param {HeadersInit} hs
+     * @returns {HttpRequestBuilder} this builder
+     */
+    headers(hs: HeadersInit): HttpRequestBuilder;
+    /**
+     * Adds an header to the request, overriding it if it already exists. Null and undefined values cause the key to be removed
+     * @param {string} k
+     * @param {string} v
+     * @returns {HttpRequestBuilder} this builder
+     */
+    header(k: string, v: string): HttpRequestBuilder;
+    /**
+     * Add all query parameters to the request, overriding existing ones if that key already exists. Null and undefined values cause the key to be removed
+     * @param {URLSearchParams|Record<string,string>|string[][]|string} ps
+     * @returns {HttpRequestBuilder} this builder
+     */
+    params(ps: URLSearchParams | Record<string, string> | string[][] | string): HttpRequestBuilder;
+    /**
+     * Adds a query parameter to the request, overriding it if it already exists. Empty vs, or a single null or undefined value cause the key to be removed.
+     * @param {string} k
+     * @param {...string} vs
+     * @returns {HttpRequestBuilder} this builder
+     */
+    param(k: string, ...vs: string[]): HttpRequestBuilder;
+    /**
+     * Sets the request body.
+     * `Content-Type: multipart/form-data` header is automatically added by fetch when data is a FormData instance if not explicitly set.
+     * `Content-Type: application/x-www-form-urlencoded` header is automatically added by fetch when data is an URLSearchParams instance if not explicitly set.
+     * `Content-Type: text/plain` header is automatically added by fetch when data is a string instance if not explicitly set.
+     * @param {string|ArrayBuffer|Blob|DataView|File|FormData|TypedArray|URLSearchParams|ReadableStream} data
+     * @returns {HttpRequestBuilder} this builder
+     */
+    body(data: string | ArrayBuffer | Blob | DataView | File | FormData | TypedArray | URLSearchParams | ReadableStream): HttpRequestBuilder;
+    /**
+     * Sets the request body that will be serialized as json. Calling this method adds the `Content-Type application/json` header for the request.
+     * @param {any} body - the body to be serialized as json
+     * @returns {HttpRequestBuilder} this builder
+     */
+    json(body: any): HttpRequestBuilder;
+    /**
+     * Sets the request body as a FormData configured using the callback.
+     * `Content-Type: multipart/form-data` header is automatically added by fetch if not explicitly set.
+     * @param {function(HttpMultipartRequestCustomizer):void} callback
+     */
+    multipart(callback: (arg0: HttpMultipartRequestCustomizer) => void): this;
+    /**
+     * Sets a fetch options for the request.
+     * @param {Omit<RequestInit,"headers"|"method"|"body">} kvs
+     * @returns {HttpRequestBuilder} this builder
+     */
+    options(kvs: Omit<RequestInit, "headers" | "method" | "body">): HttpRequestBuilder;
+    /**
+     * Sets a fetch option for the request.
+     * @param {keyof Omit<RequestInit,"headers"|"method"|"body">} k
+     * @param {*} v
+     * @returns {HttpRequestBuilder} this builder
+     */
+    option(k: keyof Omit<RequestInit, "headers" | "method" | "body">, v: any): HttpRequestBuilder;
+    /**
+     * Adds interceptors to the request.
+     * @param {[HttpInterceptor]} is - the interceptor to be regisered
+     * @returns {HttpRequestBuilder} this builder
+     */
+    interceptors(is: [HttpInterceptor]): HttpRequestBuilder;
+    /**
+     * Adds an interceptor to the request.
+     * @param {HttpInterceptor} i - the interceptor to be regisered
+     * @returns {HttpRequestBuilder} this builder
+     */
+    interceptor(i: HttpInterceptor): HttpRequestBuilder;
+    /**
+     * Performs an HTTP exchange using the configured client, request and interceptors.
+     * @returns {Promise<Response>} the response
+     */
+    exchange(): Promise<Response>;
+    /**
+     * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+     * @returns {Promise<Response>} the response
+     */
+    fetch(): Promise<Response>;
+    /**
+     * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+     * @returns {Promise<string>} the response body, as text
+     */
+    fetchText(): Promise<string>;
+    /**
+     * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+     * @returns {Promise<any>} the response body, deserialized as JSON
+     */
+    fetchJson(): Promise<any>;
+    /**
+     * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+     * @returns {Promise<Blob>} the response body, as a Blob
+     */
+    fetchBlob(): Promise<Blob>;
+    /**
+     * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+     * @returns {Promise<ArrayBuffer>} the response body, as an ArrayBuffer
+     */
+    fetchArrayBuffer(): Promise<ArrayBuffer>;
+    #private;
+}
+declare class HttpClientBuilder {
+    withCsrfToken(): this;
+    withRedirectOnUnauthorized(redirectUri: any): this;
+    /**
+     * @param {...HttpInterceptor} interceptors
+     */
+    withInterceptors(...interceptors: HttpInterceptor[]): this;
+    build(): HttpClient;
+    #private;
+}
+declare class RemoteLoader {
+    static #revisionedData(http: any, method: any, url: any, revision: any): Promise<any>;
+    constructor({ http, url, method, responseMapper, prefetch, revision }: {
+        http: any;
+        url: any;
+        method: any;
+        responseMapper: any;
+        prefetch: any;
+        revision: any;
+    });
+    prefetch(): Promise<void>;
+    exact(...keys: any[]): Promise<any>;
+    load(needle: any): Promise<any>;
+    reconfigureUrl(url: any): Promise<void>;
+    #private;
+}
+declare class PartialRemoteLoader {
+    constructor({ http, url, method, responseMapper }: {
+        http: any;
+        url: any;
+        method: any;
+        responseMapper: any;
+    });
+    exact(...keys: any[]): Promise<any>;
+    load(needle: any): Promise<any>;
+    #private;
+}
+declare class InMemoryLoader {
+    constructor(data: any);
+    update(data: any): void;
+    exact(...keys: any[]): any;
+    load(needle: any): any;
+    #private;
+}
+declare class HttpMultipartRequestCustomizer {
+    /**
+     *
+     * @param {FormData} formData
+     */
+    constructor(formData: FormData);
+    /**
+     * Appends a value to the FormData.
+     * @param {string} name
+     * @param {*} value
+     * @returns this builder
+     */
+    field(name: string, value: any): this;
+    /**
+     * Appends a Blob to the FormData.
+     * If `filename` is omitted, FormData defaults are applied:
+     * The default filename for Blob objects is "blob";
+     * The default filename for File objects is the file's filename.
+     * @param {string} name
+     * @param {Blob} value
+     * @param {string|undefined} filename
+     * @returns this builder
+     */
+    blob(name: string, value: Blob, filename: string | undefined): this;
+    /**
+     * Appends multiple Blobs to the FormData with the same name.
+     * The default filename for Blob objects is "blob";
+     * The default filename for File objects is the file's filename.
+     * @param {string} name
+     * @param {Blob[]} values
+     * @returns this builder
+     */
+    blobs(name: string, values: Blob[]): this;
+    /**
+     * Appends a JSON serialized blob to the FormData.
+     * @param {string} name
+     * @param {any} value
+     * @param {string|undefined} filename
+     * @returns this builder
+     */
+    json(name: string, value: any, filename: string | undefined): this;
+    #private;
+}
+export {};
+
+export as namespace ful;