declare class Expressions {
    #private;
    static MODE_EXPRESSION: symbol;
    static MODE_TEMPLATED: symbol;
    /**
     * Parses an expression.
     * @param {string} expression
     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
     * @returns the ast
     */
    static parse(expression: string, mode?: (typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED) | null): any;
    /**
     * Evaluates an expression.
     * @param {{[k: string]: any } | null | undefined } modules
     * @param {any[]} dataStack
     * @param {any} ast
     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
     * @returns the result
     */
    static evaluate(modules: {
        [k: string]: any;
    } | null | undefined, dataStack: any[], ast: any, mode?: (typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED) | null): any;
    /**
     * Parses and evaluates an expression.
     * @param {{ [x: string]: any; } | null | undefined} modules
     * @param {any[]} dataStack
     * @param {string} expression
     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
     * @returns the result
     */
    static interpret(modules: {
        [x: string]: any;
    } | null | undefined, dataStack: any[], expression: string, mode?: (typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED) | null): any;
}
declare class ExpressionEvaluator {
    #private;
    constructor(modules: any, dataStack: any);
    withModule(name: any, value: any): ExpressionEvaluator;
    withOverlay(...data: any[]): ExpressionEvaluator;
    evaluate(expression: any, mode: any): any;
    evaluateExpression(expression: any): any;
    evaluateTemplated(expression: any): any;
}
declare class Fragments {
    /**
     * Creates a DocumentFragment from an string.
     * @param  {...string} html
     * @returns {DocumentFragment} the fragment
     */
    static fromHtml(...html: string[]): DocumentFragment;
    /**
     * Creates a string representation (HTML) of a DocumentFragment.
     * @param {DocumentFragment} fragment
     * @returns {string} the html
     */
    static toHtml(fragment: DocumentFragment): string;
    /**
     * Checks if a fragment contains only blank text nodes
     * @param {DocumentFragment} fragment
     * @returns {boolean} true if the fragment is blank
     */
    static isBlank(fragment: DocumentFragment): boolean;
    /**
     * Creates a DocumentFragment from nodes.
     * @param  {...Node} nodes
     * @returns {DocumentFragment} the fragment
     */
    static from(...nodes: Node[]): DocumentFragment;
    /**
     * Creates a DocumentFragment from childNodes of an element.
     * @param {Node} el
     * @returns {DocumentFragment} the fragment
     */
    static fromChildNodes(el: Node): DocumentFragment;
}
declare class Attributes {
    static id: number;
    /**
     * Creates a unique id with the given prefix.
     * @param {string} prefix
     * @returns
     */
    static uid(prefix: string): string;
    /**
     * Sets an attribute if not present.
     * @param {Element} el
     * @param {string} k
     * @param {string} v
     * @returns
     */
    static defaultValue(el: Element, k: string, v: string): string | null;
    /**
     * Forwards prefixed attributes from an element to another (removing the prefix).
     * @param {string} prefix
     * @param {Element} from
     * @param {Element} to
     */
    static forward(prefix: string, from: Element, to: Element): void;
    /**
     * Changes the presence of an attribute.
     * @param {Element} el
     * @param {string} attr
     * @param {boolean} value
     */
    static toggle(el: Element, attr: string, value: boolean): void;
    /**
     * Changes the presence of an attribute based on its current state.
     * @param {Element} el
     * @param {string} attr
     */
    static flip(el: Element, attr: string): void;
    /**
     * Sets the value of an attribute. nullish values remove the attribute.
     * @param {Element} el
     * @param {string} attr
     * @param {string | null | undefined} value
     */
    static set(el: Element, attr: string, value: string | null | undefined): void;
}
declare class LightSlots {
    /**
     * Extracts light slots from an element. For non default slots in a template tag, the content is extracted.
     * @param {Element} el
     * @returns the slots
     */
    static from(el: Element): {
        default: DocumentFragment;
    };
    static slotFromNode(el: any): any;
}
declare class Nodes {
    /**
     * Checks if an element is already parsed.
     * @param {Element} el
     * @returns
     */
    static isParsed(el: Element): boolean;
    static waitParsed(el: any): Promise<any>;
    /**
     * Returns the first child of the element element (if exists) matching the selector.
     * @param {Element} el
     * @param {string} selector
     * @returns
     */
    static queryChildren(el: Element, selector: string): Element | null;
    /**
     * Returns all children of the element matching the selector.
     * @param {Element} el
     * @param {string} selector
     * @returns
     */
    static queryChildrenAll(el: Element, selector: string): Element[];
}
declare class Template {
    #private;
    /**
     * Creates a template from a string.
     * @param {string} html
     * @param {{ [k: string] : any }?} [modules]
     * @param {...*} data
     * @returns the template
     */
    static fromHtml(html: string, modules?: {
        [k: string]: any;
    } | null, ...data: any[]): Template;
    /**
     * Creates a template from the content of the first template element matching the selector.
     * @param {string} selector for an HTMLTemplateElement
     * @param {{ [k: string] : any }?} [modules]
     * @param {...*} data
     * @returns the template
     */
    static fromSelector(selector: string, modules?: {
        [k: string]: any;
    } | null, ...data: any[]): Template;
    /**
     * Creates a template from the content of an HTMLTemplateElement.
     * @param {HTMLTemplateElement} templateEl
     * @param {{ [k: string] : any }?} [modules]
     * @param {...*} data
     * @returns the template
     */
    static fromTemplate(templateEl: HTMLTemplateElement, modules?: {
        [k: string]: any;
    } | null, ...data: any[]): Template;
    /**
     * Creates a template from a DocumentFragment.
     * @param {DocumentFragment} fragment
     * @param { { [k: string] : any }? } [modules]
     * @param {...*} data
     * @returns the template
     */
    static fromFragment(fragment: DocumentFragment, modules?: {
        [k: string]: any;
    } | null, ...data: any[]): Template;
    /**
     * Creates a template.
     * @param {DocumentFragment} fragment
     * @param {{ [x: string]: any; } | null | undefined} modules
     * @param {any[]} dataStack
     */
    constructor(fragment: DocumentFragment, modules: {
        [x: string]: any;
    } | null | undefined, dataStack: any[]);
    /**
     * Creates a new Template replacing the modules and dataStack from a context.
     * @param {{modules: { [x: string]: any; } | null | undefined, data: any[]}} context
     */
    withContext({ modules, data }: {
        modules: {
            [x: string]: any;
        } | null | undefined;
        data: any[];
    }): Template;
    /**
     * Creates a new Template replacing the modules and dataStack from a registry.
     * @param any registry
     */
    withContextFrom(registry: any): Template;
    /**
     * Creates a new Template replacing the fragment.
     * @param {DocumentFragment} fragment
     */
    withFragment(fragment: DocumentFragment): Template;
    /**
     * Creates a new Template with a new module added.
     * @param {string?} name
     * @param {{[k: string]: any}} value
     */
    withModule(name: string | null, value: {
        [k: string]: any;
    }): Template;
    /**
     * Creates a new Template replacing the modules.
     * @param {{ [x: string]: any; }?} modules
     */
    withModules(modules: {
        [x: string]: any;
    } | null): Template;
    /**
     * Creates a new Template replacing the data stack.
     * @param {any[]} dataStack the dataStack
     */
    withData(dataStack: any[]): Template;
    /**
     * Creates a new Template with new a data overlay added to the stack.
     * @param {...*} data
     */
    withOverlay(...data: any[]): Template;
    /**
     * Evaluates an expression using the configured modules and data.
     * @param {string} expression
     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
     * @param {...*} data
     */
    evaluate(expression: string, mode?: (typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED) | null, ...data: any[]): void;
    /**
     * Returns an expression evaluator with bound modules and dataStack.
     */
    evaluator(): ExpressionEvaluator;
    /**
     * Renders the template.
     * @returns a DocumentFragment
     */
    render(): DocumentFragment;
    /**
     * Renders this template on the Element (replacing children).
     * @param {Element} el
     */
    renderTo(el: Element): void;
    /**
     * Renders this template appending the resulting fragment to the Element.
     * @param {Element} el
     */
    appendTo(el: Element): void;
    /**
     * Renders this template appending the resulting fragment to the first Element maching the selector, if exists.
     * @param {string} selector
     */
    renderToSelector(selector: string): void;
    /**
     * Renders this template appending the resulting fragment to the Element maching the selector, if exists.
     * @param {string} selector
     */
    appendToSelector(selector: string): void;
}
declare class RenderError extends Error {
    #private;
    node: any;
    constructor(message: any, nodeOrFragment: any, cause: any);
    static stringify(nodeOrFragment: any): string;
}
declare class Registry {
    #private;
    defineElement(tag: any, klass: any): this;
    defineModule(name: any, value: any): this;
    defineModules(ms: any): this;
    defineComponent(name: any, value: any): this;
    defineData(...data: any[]): this;
    defineOverlay(...data: any[]): this;
    defineMapper(k: any, v: any): this;
    plugin(p: any): this;
    configure(): this;
    get upgrades(): MapIterator<[any, any]>;
    context(): {
        modules: any;
        data: any[];
    };
    evaluator(): ExpressionEvaluator;
    component(name: any): any;
}
declare const registry: Registry;
declare class Templates {
    static fromHtml(html: any): Template;
    static fromSelector(selector: any): Template;
    static fromTemplate(templateEl: any): Template;
    static fromFragment(fragment: any): Template;
}
declare class Rendering {
    static waitFor(el: any): Promise<void>;
    static waitForChildren(el: any): Promise<void>;
}
export type Mapper = {
    unmarshal: (val: string | null | undefined, name: string, el: Element) => any;
    marshal: (val: any, name: string, el: Element) => string | null;
};
/**
 * An attribute Mapper.
 *
 * @typedef {object} Mapper
 * @property {(val: string|null|undefined, name: string, el: Element) => any} unmarshal
 * @property {(val: any, name: string, el: Element) => string|null} marshal
 */
declare class ParsedElement extends HTMLElement {
    #private;
    static BITS: {
        enqueue: (el: any) => void;
        SLOTS: boolean;
        OBSERVED: never[];
        /** @type {Record<string, Mapper>} */
        ATTR_TO_MAPPER: Record<string, Mapper>;
        TEMPLATES: {};
    };
    static get observedAttributes(): never[];
    unmarshal(attr: any, str: any): any;
    marshal(attr: any, value: any): string | null;
    /**
     * @param {string} [name] - The name of the template target, defaults to 'default'
     */
    template(name?: string): any;
    connectedCallback(): void;
    attributeChangedCallback(attr: any, oldValue: any, newValue: any): void;
    formDisabledCallback(disabled: any): void;
    upgrade(): Promise<void>;
    render(c: any): void;
    reflect(fn: any): void;
    reflectTo(attr: any, value: any): void;
}
export type Problem = {
    type: string;
    context: string | null;
    reason: string;
    details: any | null;
};
/**
 * @typedef {{ type: string; context: string?; reason: string; details: any?; }} Problem
 */
declare class Failure extends Error {
    problems: Problem[];
    /**
     *
     * @param {string} message
     * @param {Problem[]} problems
     * @param {*} cause
     */
    constructor(message: string, problems: Problem[], cause: any);
    dropping(prefix: any): Failure;
    static dropProblemsContext(problems: any, prefix: any): any;
}
declare class Base64 {
    static encode(arrayBuffer: any, dialect: any): string;
    static decode(str: any, dialect: any): ArrayBuffer;
}
declare namespace Base64 {
    var STANDARD: string;
    var URL_SAFE: string;
}
declare class Hex {
    static decode(hex: any): Uint8Array<ArrayBuffer>;
    static encode(bytes: any, upper: any): string;
}
declare class MediaType {
    #private;
    constructor(type: any, subtype: any);
    get normalized(): string;
    get type(): any;
    get subtype(): any;
    /**
     *
     * @param {string|null|undefined} v
     * @returns
     */
    static parse(v: string | null | undefined): MediaType;
}
export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
export type HttpInterceptor = {
    intercept: (url: URL, init: RequestInit | undefined, chain: HttpInterceptorChain) => Promise<Response>;
};
/**
 * @typedef {Int8Array| Uint8Array| Uint8ClampedArray| Int16Array| Uint16Array| Int32Array| Uint32Array| Float32Array| Float64Array| BigInt64Array| BigUint64Array} TypedArray
 */
/**
 * @typedef {object} HttpInterceptor
 * @property {(url: URL, init: RequestInit|undefined, chain: HttpInterceptorChain) => Promise<Response>} intercept
 */
declare class HttpClientError extends Failure {
    status: number;
    /**
     * @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);
    dropping(prefix: any): HttpClientError;
    /**
     *
     * @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>;
}
declare class HttpClientBuilder {
    #private;
    constructor();
    withCsrfToken(): this;
    withRedirectOnUnauthorized(redirectUri: any): this;
    /**
     * @param {...HttpInterceptor} interceptors
     */
    withInterceptors(...interceptors: HttpInterceptor[]): this;
    build(): HttpClient;
}
declare class HttpInterceptorChain {
    #private;
    /**
     *
     * @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>;
}
declare class HttpClient {
    #private;
    /**
     * 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;
}
declare class HttpRequestBuilder {
    #private;
    /**
     * 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: Function): 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>;
}
declare 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;
}
declare 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;
}
declare class VersionedLocalStorage {
    static save(key: any, revision: any, data: any): void;
    static load(key: any, revision: any): any;
}
declare class VersionedSessionStorage {
    static save(key: any, revision: any, data: any): void;
    static load(key: any, revision: any): any;
}
export type AsyncExtension = {
    promises: Promise<any>[];
};
export type AsyncEvent = Event & {
    async?: AsyncExtension;
};
/**
 * @typedef {Object} AsyncExtension
 * @property {Promise<any>[]} promises
 * @typedef {Event & { async?: AsyncExtension }} AsyncEvent
 */
declare 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;
}
declare 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];
}
declare 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;
}
declare class RemoteJsonFormLoader {
    #private;
    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;
}
declare class LocalFormLoader {
    #private;
    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>;
}
declare class FormLoader {
    static create(el: any, conf: any): LocalFormLoader | RemoteJsonFormLoader;
}
declare class Form extends ParsedElement {
    form: any;
    render(): void;
    /**
     *
     * @param {HTMLElement} [submitter]
     * @returns
     */
    submit(submitter?: HTMLElement): Promise<void>;
    reset(): void;
    spinner(spin: any): void;
    set values(vs: {});
    get values(): {};
    set errors(es: any);
}
declare class Input extends ParsedElement {
    internals: ElementInternals;
    static observed: string[];
    static slots: boolean;
    static template: string;
    static formAssociated: boolean;
    _input: any;
    _fieldError: any;
    constructor();
    _type(): string;
    _fragment(type: any, slots: any): any;
    render({ slots, observed, disabled, skipObservedSetup }: {
        disabled: any;
        observed: any;
        skipObservedSetup: any;
        slots: any;
    }): void;
    get value(): any;
    set value(value: any);
    get readonly(): any;
    set readonly(v: any);
    get disabled(): any;
    set disabled(d: any);
    get required(): boolean;
    set required(d: boolean);
    focus(options: any): void;
    setCustomValidity(error: any): void;
    formResetCallback(): void;
}
declare class LocalDate extends ParsedElement {
    render(): void;
}
declare class Instant extends ParsedElement {
    render(): void;
    static isoToLocal(iso: any): string;
}
declare class InputLocalDate extends Input {
    #private;
    static observed: string[];
    _type(): string;
    render(conf: any): void;
    get min(): any;
    set min(v: any);
    get max(): any;
    set max(v: any);
    get step(): any;
    set step(v: any);
}
declare class InputLocalTime extends InputLocalDate {
    _type(): string;
}
declare class InputInstant extends Input {
    static observed: string[];
    _type(): string;
    render(conf: any): void;
    get value(): string | null;
    set value(v: string | null);
    get min(): string | null;
    set min(v: string | null);
    get max(): string | null;
    set max(v: string | null);
    get step(): any;
    set step(v: any);
}
declare class InputFile extends Input {
    #private;
    static l10n: {
        en: {
            dropzonelabel: string;
            unaccepptablefiletype: string;
            maxfilesizeexceeded: string;
            maxtotalsizeexceeded: string;
            maxfilesexceeded: string;
        };
        it: {
            dropzonelabel: string;
            unaccepptablefiletype: string;
            maxfilesizeexceeded: string;
            maxtotalsizeexceeded: string;
            maxfilesexceeded: string;
        };
        es: {
            dropzonelabel: string;
            unaccepptablefiletype: string;
            maxfilesizeexceeded: string;
            maxtotalsizeexceeded: string;
            maxfilesexceeded: string;
        };
        fr: {
            dropzonelabel: string;
            unaccepptablefiletype: string;
            maxfilesizeexceeded: string;
            maxtotalsizeexceeded: string;
            maxfilesexceeded: string;
        };
    };
    static observed: string[];
    _type(): string;
    static template: string;
    static templates: {
        items: string;
        warning: string;
    };
    render(conf: any): void;
    warning(key: any, args: any): void;
    get accept(): any;
    set accept(vs: any);
    get multiple(): any;
    set multiple(v: any);
    get files(): any;
    set files(vs: any);
    get file(): any;
    set file(v: any);
    get value(): any;
    set value(v: any);
    get totalsize(): any;
    get maxfiles(): any;
    set maxfiles(v: any);
    get maxfilesize(): any;
    set maxfilesize(v: any);
    get maxtotalsize(): any;
    set maxtotalsize(v: any);
    get itemlist(): any;
    set itemlist(v: any);
    get dropzone(): any;
    set dropzone(v: any);
}
declare class RemoteLoader {
    #private;
    constructor({ http, url, method, responseMapper, prefetch, revision }: {
        http: any;
        method: any;
        prefetch: any;
        responseMapper: any;
        revision: any;
        url: any;
    });
    prefetch(): Promise<void>;
    exact(...keys: any[]): Promise<any>;
    load(needle: any): Promise<any>;
    reconfigureUrl(url: any): Promise<void>;
}
declare class PartialRemoteLoader {
    #private;
    constructor({ http, url, method, responseMapper }: {
        http: any;
        method: any;
        responseMapper: any;
        url: any;
    });
    exact(...keys: any[]): Promise<any>;
    load(needle: any): Promise<any>;
}
declare class InMemoryLoader {
    #private;
    constructor(data: any);
    update(data: any): void;
    exact(...keys: any[]): any;
    load(needle: any): any;
}
declare class SelectLoader {
    #private;
    static create(el: any, conf: any): InMemoryLoader | PartialRemoteLoader | RemoteLoader;
}
declare class Dropdown extends ParsedElement {
    #private;
    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>;
}
declare class Select extends ParsedElement {
    #private;
    static observed: string[];
    static slots: boolean;
    static template: string;
    static templates: {
        items: string;
    };
    static formAssociated: boolean;
    internals: ElementInternals;
    constructor();
    render({ slots, observed, disabled }: {
        disabled: any;
        observed: any;
        slots: any;
    }): Promise<void>;
    withLoader(fn: any): Promise<any>;
    set value(vs: any);
    get value(): any;
    get entry(): [any, any][] | [any, any];
    get disabled(): any;
    set disabled(d: any);
    get readonly(): any;
    set readonly(v: any);
    get required(): boolean;
    set required(d: boolean);
    get itemlist(): any;
    set itemlist(v: any);
    focus(options: any): void;
    setCustomValidity(error: any): void;
}
declare class RadioGroup extends ParsedElement {
    #private;
    internals: ElementInternals;
    static observed: string[];
    static slots: boolean;
    static template: string;
    static formAssociated: boolean;
    constructor();
    render({ slots, observed, disabled }: {
        disabled: any;
        observed: any;
        slots: any;
    }): void;
    get value(): string | boolean | null;
    set value(value: string | boolean | null);
    get readonly(): any;
    set readonly(v: any);
    get disabled(): any;
    set disabled(d: any);
    get required(): boolean;
    set required(d: boolean);
    focus(options: any): void;
    setCustomValidity(error: any): void;
}
declare class Checkbox extends ParsedElement {
    #private;
    internals: ElementInternals;
    static observed: string[];
    static slots: boolean;
    static template: string;
    static formAssociated: boolean;
    constructor();
    render({ slots, observed, disabled }: {
        disabled: any;
        observed: any;
        slots: any;
    }): void;
    get value(): any;
    set value(value: any);
    get readonly(): any;
    set readonly(v: any);
    get disabled(): any;
    set disabled(d: any);
    get required(): boolean;
    set required(d: boolean);
    focus(options: any): void;
    setCustomValidity(error: any): void;
}
declare class Spinner extends ParsedElement {
    static slots: boolean;
    static template: string;
    render({ slots }: {
        slots: any;
    }): void;
}
declare class SortButton extends ParsedElement {
    #private;
    static observed: string[];
    render(): void;
    get order(): any;
    set order(value: any);
}
declare class Pagination extends ParsedElement {
    #private;
    static observed: string[];
    static l10n: {
        en: {
            showing: string;
            navigation: string;
            previous: string;
            next: string;
        };
        it: {
            showing: string;
            navigation: string;
            previous: string;
            next: string;
        };
        es: {
            showing: string;
            navigation: string;
            previous: string;
            next: string;
        };
        fr: {
            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;
    get total(): number;
    set total(value: number);
    get current(): number;
    set current(value: number);
}
declare class TableSchemaParser {
    static parse(nodeOrFragment: any, template: any): {
        headersTemplate: any;
        rowsTemplate: any;
        sort: {
            sorter: string | null;
            order: string | null;
        };
        length: number;
    };
}
declare class Table extends ParsedElement {
    #private;
    static slots: boolean;
    static l10n: {
        en: {
            initial: string;
            error: string;
            nodata: string;
        };
        it: {
            initial: string;
            error: string;
            nodata: string;
        };
        es: {
            initial: string;
            error: string;
            nodata: string;
        };
        fr: {
            initial: string;
            error: string;
            nodata: string;
        };
    };
    static config: {
        searchIcon: string;
    };
    static template: string;
    static templates: {
        row: string;
    };
    render({ slots, observed }: {
        observed: any;
        slots: 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>;
}
declare class InstantFilter extends Input {
    #private;
    static observed: string[];
    static template: string;
    render(conf: any): void;
    get value(): any[] | undefined;
    set value(v: any[] | undefined);
    set readonly(v: any);
    set disabled(d: any);
}
declare class LocalDateFilter extends Input {
    #private;
    static observed: string[];
    static template: string;
    render(conf: any): void;
    get value(): any[] | undefined;
    set value(v: any[] | undefined);
    set readonly(v: any);
    set disabled(d: any);
}
declare class TextFilter extends Input {
    #private;
    static observed: string[];
    static template: string;
    render(conf: any): void;
    get value(): any[] | undefined;
    set value(v: any[] | undefined);
}
declare class LocalizationModule {
    static t(k: any, ...args: any[]): any;
    static tl(k: any, args?: any[]): any;
}
declare class Plugin {
    configure(registry: any): void;
}
export { AsyncEvents, Attributes, Base64, Bindings, Checkbox, Dropdown, ExpressionEvaluator, Expressions, Failure, Form, FormLoader, Fragments, Hex, HttpClient, HttpClientError, Input, InputFile, InputInstant, InputLocalDate, InputLocalTime, Instant, InstantFilter, LightSlots, LocalDate, LocalDateFilter, LocalStorage, LocalizationModule, MediaType, Nodes, Pagination, ParsedElement, Plugin, RadioGroup, Registry, RenderError, Rendering, Select, SelectLoader, SessionStorage, SortButton, Spinner, Table, TableSchemaParser, Template, Templates, TextFilter, Timing, VersionedLocalStorage, VersionedSessionStorage, registry };

export as namespace fml;