@optionfactory/ful
Version:
This is a minimalistic web components library built on top of [`@optionfactory/ftl`](https://github.com/optionfactory/ftl) to accelerate frontend development cycle-time. Strictly adhering to a no-build philosophy, it completely eliminates the downtime as
942 lines (940 loc) • 31.2 kB
text/typescript
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;