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;