export interface ProjectorService { /**
     * Instructs the projector to re-render to the DOM at the next animation-frame using the registered `render` functions.
     * This method is automatically called for you when event-handlers that are registered in the [[VNode]]s are invoked.
     *
     * You need to call this method when timeouts expire, when AJAX responses arrive or other asynchronous actions happen.
     */ scheduleRender ( ) : void ; /**
     * Synchronously re-renders to the DOM. You should normally call the `scheduleRender()` function to keep the
     * user interface more performant. There is however one good reason to call renderNow(),
     * when you want to put the focus into a newly created element in iOS.
     * This is only allowed when triggered by a user-event, not during requestAnimationFrame.
     */ renderNow ( ) : void ; } export interface Projector extends ProjectorService { param parentNode param renderFunction append ( parentNode , renderFunction ) : void ; param beforeNode param renderFunction insertBefore ( beforeNode , renderFunction ) : void ; param domNode param renderFunction merge ( domNode , renderFunction ) : void ; param domNode param renderFunction replace ( domNode , renderFunction ) : void ; /**
     * Resumes the projector. Use this method to resume rendering after [[stop]] was called or an error occurred during rendering.
     */ resume ( ) : void ; returns detach ( renderFunction ) : Projection ; /**
     * Stops the projector. This means that the registered `render` functions will not be called anymore.
     *
     * Note that calling [[stop]] is not mandatory. A projector is a passive object that will get garbage collected
     * as usual if it is no longer in scope.
     */ stop ( ) : void ; } /**
 * A virtual representation of a DOM Node. Maquette assumes that [[VNode]] objects are never modified externally.
 * Instances of [[VNode]] can be created using [[h]].
 */ export interface VNode { /**
     * The CSS selector containing tagname, css classnames and id. An empty string is used to denote a text node.
     */ readonly vnodeSelector : string ; /**
     * Object containing attributes, properties, event handlers and more, see [[h]].
     */ readonly properties : VNodeProperties | undefined ; /**
     * Array of [[VNode]]s to be used as children. This array is already flattened.
     */ readonly children : VNode [ ] | undefined ; /**
     * Used in a special case when a [[VNode]] only has one child node which is a text node. Only used in combination with children === undefined.
     */ readonly text : string | undefined ; /**
     * Used by maquette to store the domNode that was produced from this [[VNode]].
     */ domNode : Node | null ; } /**
 * Object containing attributes, properties, event handlers and more that can be put on DOM nodes.
 *
 * For your convenience, all common attributes, properties and event handlers are listed here and are
 * type-checked when using Typescript.
 */ export interface VNodeProperties { /**
     * The animation to perform when this node is added to an already existing parent.
     *  http .
     *  param element param properties enterAnimation ? : ( element : Element , properties ? : VNodeProperties ) => void ; param element param removeElement param properties exitAnimation ? ( element , removeElement , properties ? ) : void ; /**
     * The animation to perform when the properties of this node change.
     * This also includes attributes, styles, css classes. This callback is also invoked when node contains only text and that text changes.
     *  http .
     *  param element param properties param previousProperties updateAnimation ? ( element , properties ? , previousProperties ? ) : void ; param element param projectionOptions param vnodeSelector param properties param children afterCreate ? ( element , projectionOptions , vnodeSelector , properties , children ) : void ; param element param projectionOptions param vnodeSelector param properties param children afterUpdate ? ( element , projectionOptions , vnodeSelector , properties , children ) : void ; /**
     * Callback that is called when a node has been removed from the tree.
     * The callback is called during idle state or after a timeout (fallback).
     *  https param element afterRemoved ? ( element ) : void ; /**
     * When specified, the event handlers will be invoked with 'this' pointing to the value.
     * This is useful when using the prototype/class based implementation of MaquetteComponents.
     *
     * When no [[key]] is present, this object is also used to uniquely identify a DOM node.
     */ readonly bind ? : unknown ; /**
     * Used to uniquely identify a DOM node among siblings.
     * A key is required when there are more children with the same selector and these children are added or removed dynamically.
     * NOTE: this does not have to be a string or number, a [[MaquetteComponent]] Object for instance is also common.
     */ readonly key ? : unknown ; /**
     * An object literal like `{important:true}` which allows css classes, like `important` to be added and removed
     * dynamically.
     */ readonly classes ? : { [ index ] : boolean | null | undefined ; } ; /**
     * An object literal like `{height:'100px'}` which allows styles to be changed dynamically. All values must be strings.
     */ readonly styles ? : Partial < CSSStyleDeclaration > | { [ cssVariable ] : string ; } ; ontouchcancel ? ( ev ) : boolean | void ; ontouchend ? ( ev ) : boolean | void ; ontouchmove ? ( ev ) : boolean | void ; ontouchstart ? ( ev ) : boolean | void ; readonly action ? : string ; readonly encoding ? : string ; readonly enctype ? : string ; readonly method ? : string ; readonly name ? : string ; readonly target ? : string ; readonly href ? : string ; readonly rel ? : string ; onblur ? ( ev ) : boolean | void ; onchange ? ( ev ) : boolean | void ; onclick ? ( ev ) : boolean | void ; ondblclick ? ( ev ) : boolean | void ; ondrag ? ( ev ) : boolean | void ; ondragend ? ( ev ) : boolean | void ; ondragenter ? ( ev ) : boolean | void ; ondragleave ? ( ev ) : boolean | void ; ondragover ? ( ev ) : boolean | void ; ondragstart ? ( ev ) : boolean | void ; ondrop ? ( ev ) : boolean | void ; onfocus ? ( ev ) : boolean | void ; oninput ? ( ev ) : boolean | void ; onkeydown ? ( ev ) : boolean | void ; onkeypress ? ( ev ) : boolean | void ; onkeyup ? ( ev ) : boolean | void ; onload ? ( ev ) : boolean | void ; onmousedown ? ( ev ) : boolean | void ; onmouseenter ? ( ev ) : boolean | void ; onmouseleave ? ( ev ) : boolean | void ; onmousemove ? ( ev ) : boolean | void ; onmouseout ? ( ev ) : boolean | void ; onmouseover ? ( ev ) : boolean | void ; onmouseup ? ( ev ) : boolean | void ; onmousewheel ? ( ev ) : boolean | void ; onscroll ? ( ev ) : boolean | void ; onsubmit ? ( ev ) : boolean | void ; readonly spellcheck ? : boolean ; readonly tabIndex ? : number ; readonly disabled ? : boolean ; readonly title ? : string ; readonly accessKey ? : string ; readonly class ? : string ; readonly id ? : string ; readonly draggable ? : boolean ; readonly type ? : string ; readonly autocomplete ? : string ; readonly checked ? : boolean ; readonly placeholder ? : string ; readonly readOnly ? : boolean ; readonly src ? : string ; readonly value ? : string ; readonly alt ? : string ; readonly srcset ? : string ; /**
     * Puts a non-interactive string of html inside the DOM node.
     *
     * Note: if you use innerHTML, maquette cannot protect you from XSS vulnerabilities and you must make sure that the innerHTML value is safe.
     */ readonly innerHTML ? : string ; /**
     * Do not use className, use class instead
     */ readonly className ? : never | "Hint: do not use `className`, use `class` instead" ; /**
     * Everything that is not explicitly listed (properties and attributes that are either uncommon or custom).
     */ readonly [ index ] : any ; } /**
 * Only needed for the definition of [[VNodeChild]].
 */ export interface VNodeChildren extends Array < VNodeChild > { } /**
 * These are valid values for the children parameter of the [[h]] function.
 */ export type VNodeChild = string | VNode | VNodeChildren | false | null | undefined ; /**
 * Represents a [[VNode]] tree that has been rendered to a real DOM tree.
 */ export interface Projection { /**
     * The DOM node that is used as the root of this [[Projection]].
     */ readonly domNode : Element ; param updatedVnode update ( updatedVnode ) : void ; getLastRender ( ) : VNode ; } export type EventHandler = ( this : Node , event : Event ) => boolean | undefined | void ; /**
 * Options that influence how the DOM is rendered and updated.
 */ export type EventHandlerInterceptor = ( propertyName : string , eventHandler : EventHandler , domNode : Node , properties : VNodeProperties ) => undefined | EventHandler ; export type PerformanceLoggerEvent = "domEvent" | "domEventProcessed" | "renderStart" | "rendered" | "patched" | "renderDone" ; export type ProjectorPerformanceLogger = ( eventType : PerformanceLoggerEvent , trigger : Event | undefined ) => void ; /**
 * Options that may be passed when creating the [[Projector]]
 */ export interface ProjectorOptions { /**
     * Can be used to log performance metrics
     */ performanceLogger ? : ProjectorPerformanceLogger ; param domNode param styleName param value styleApplyer ? ( domNode , styleName , value ) : void ; } export interface ProjectionOptions extends ProjectorOptions { /**
     * Only for internal use. Used for rendering SVG Nodes.
     */ readonly namespace ? : string ; param propertyName param eventHandler param domNode param properties returns eventHandlerInterceptor ? : EventHandlerInterceptor ; } /**
 * Keeps an array of result objects synchronized with an array of source objects.
 * See  http .
 *
 * Mapping provides a [[map]] function that updates its [[results]].
 * The [[map]] function can be called multiple times and the results will get created, removed and updated accordingly.
 * A Mapping can be used to keep an array of components (objects with a `render` method) synchronized with an array of data.
 * Instances of Mapping can be created using [[createMapping]].
 *
 *  param param export interface Mapping < Source , Target > { /**
     * The array of results. These results will be synchronized with the latest array of sources that were provided using [[map]].
     */ results : Target [ ] ; param newSources map ( newSources ) : void ; } param export interface CalculationCache < Result > { /**
     * Manually invalidates the cached outcome.
     */ invalidate ( ) : void ; param inputs param calculation result ( inputs , calculation ) : Result ; } deprecated since export interface Component { renderMaquette ( ) : VNode | null | undefined ; } /**
 * A component is a pattern with which you can split up your web application into self-contained parts.
 *
 * A component may contain other components.
 * This can be achieved by calling the subcomponents `render` functions during the [[render]] function and by using the
 * resulting [[VNode]]s in the return value.
 *
 * This interface is not used anywhere in the maquette sourcecode, but this is a widely used pattern.
 */ export interface MaquetteComponent { /**
     * A function that returns the DOM representation of the component.
     */ render ( ) : VNode | null | undefined ; } export interface Dom { param vnode param projectionOptions returns create ( vnode , projectionOptions ? ) : Projection ; param parentNode param vnode param projectionOptions returns append ( parentNode , vnode , projectionOptions ? ) : Projection ; param beforeNode param vnode param projectionOptions returns insertBefore ( beforeNode , vnode , projectionOptions ? ) : Projection ; param element param vnode param projectionOptions returns merge ( element , vnode , projectionOptions ? ) : Projection ; param element param vnode param projectionOptions returns replace ( element , vnode , projectionOptions ? ) : Projection ; }