@types/mithril

  • Version 2.0.11
  • Published
  • 32.4 kB
  • No dependencies
  • MIT license

Install

npm i @types/mithril
yarn add @types/mithril
pnpm add @types/mithril

Overview

TypeScript definitions for Mithril

Index

Variables

variable Mithril

const Mithril: Mithril.Static;

    Functions

    function jsonp

    jsonp: {
    <T>(options: Mithril.JsonpOptions & { url: string }): Promise<T>;
    <T>(url: string, options?: Mithril.JsonpOptions): Promise<T>;
    };
    • Makes a JSON-P request and returns a promise.

    function mount

    mount: {
    (element: Element, component: Mithril.ComponentTypes<any, any>): void;
    (element: Element, component: null): void;
    };
    • Mounts a component to a DOM element, enabling it to autoredraw on user events.

    • Unmounts a component from a DOM element.

    function render

    render: (el: Element, vnodes: Mithril.Children) => void;
    • Renders a vnode structure into a DOM element.

    function request

    request: {
    <T>(options: Mithril.RequestOptions<T> & { url: string }): Promise<T>;
    <T>(url: string, options?: Mithril.RequestOptions<T>): Promise<T>;
    };
    • Makes an XHR request and returns a promise.

    Interfaces

    interface Attributes

    interface Attributes extends CommonAttributes<any, any> {}
    • This represents the attributes available for configuring virtual elements, beyond the applicable DOM attributes.

    property class

    class?: string | undefined;
    • The class name(s) for this virtual element, as a space-separated list.

    property className

    className?: string | undefined;
    • The class name(s) for this virtual element, as a space-separated list.

    index signature

    [property: string]: any;
    • Any other virtual element properties, including attributes and event handlers.

    interface ChildArray

    interface ChildArray extends Array<Children> {}

      interface ClassComponent

      interface ClassComponent<A = {}> {}
      • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Any class that implements a view method can be used as a Mithril component. Components can be consumed via the m() utility.

      method onbeforeremove

      onbeforeremove: (vnode: VnodeDOM<A, this>) => Promise<any> | void;
      • The onbeforeremove hook is called before a DOM element is detached from the document. If a Promise is returned, Mithril only detaches the DOM element after the promise completes.

      method onbeforeupdate

      onbeforeupdate: (
      vnode: Vnode<A, this>,
      old: VnodeDOM<A, this>
      ) => boolean | void;
      • The onbeforeupdate hook is called before a vnode is diffed in a update.

      method oncreate

      oncreate: (vnode: VnodeDOM<A, this>) => any;
      • The oncreate hook is called after a DOM element is created and attached to the document.

      method oninit

      oninit: (vnode: Vnode<A, this>) => any;
      • The oninit hook is called before a vnode is touched by the virtual DOM engine.

      method onremove

      onremove: (vnode: VnodeDOM<A, this>) => any;
      • The onremove hook is called before a DOM element is removed from the document.

      method onupdate

      onupdate: (vnode: VnodeDOM<A, this>) => any;
      • The onupdate hook is called after a DOM element is updated, while attached to the document.

      method view

      view: (vnode: Vnode<A, this>) => Children | null | void;
      • Creates a view out of virtual elements.

      interface CommonAttributes

      interface CommonAttributes<Attrs, State> {}

        property key

        key?: string | number | undefined;
        • A key to optionally associate with this element.

        method onbeforeremove

        onbeforeremove: (
        this: State,
        vnode: VnodeDOM<Attrs, State>
        ) => Promise<any> | void;
        • The onbeforeremove hook is called before a DOM element is detached from the document. If a Promise is returned, Mithril only detaches the DOM element after the promise completes.

        method onbeforeupdate

        onbeforeupdate: (
        this: State,
        vnode: Vnode<Attrs, State>,
        old: VnodeDOM<Attrs, State>
        ) => boolean | void;
        • The onbeforeupdate hook is called before a vnode is diffed in a update.

        method oncreate

        oncreate: (this: State, vnode: VnodeDOM<Attrs, State>) => any;
        • The oncreate hook is called after a DOM element is created and attached to the document.

        method oninit

        oninit: (this: State, vnode: Vnode<Attrs, State>) => any;
        • The oninit hook is called before a vnode is touched by the virtual DOM engine.

        method onremove

        onremove: (this: State, vnode: VnodeDOM<Attrs, State>) => any;
        • The onremove hook is called before a DOM element is removed from the document.

        method onupdate

        onupdate: (this: State, vnode: VnodeDOM<Attrs, State>) => any;
        • The onupdate hook is called after a DOM element is updated, while attached to the document.

        interface Component

        interface Component<Attrs = {}, State = {}> {}
        • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Any Javascript object that has a view method can be used as a Mithril component. Components can be consumed via the m() utility.

        method onbeforeremove

        onbeforeremove: (
        this: _NoLifecycle<this & State>,
        vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>
        ) => Promise<any> | void;
        • The onbeforeremove hook is called before a DOM element is detached from the document. If a Promise is returned, Mithril only detaches the DOM element after the promise completes.

        method onbeforeupdate

        onbeforeupdate: (
        this: _NoLifecycle<this & State>,
        vnode: Vnode<Attrs, _NoLifecycle<this & State>>,
        old: VnodeDOM<Attrs, _NoLifecycle<this & State>>
        ) => boolean | void;
        • The onbeforeupdate hook is called before a vnode is diffed in a update.

        method oncreate

        oncreate: (
        this: _NoLifecycle<this & State>,
        vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>
        ) => any;
        • The oncreate hook is called after a DOM element is created and attached to the document.

        method oninit

        oninit: (
        this: _NoLifecycle<this & State>,
        vnode: Vnode<Attrs, _NoLifecycle<this & State>>
        ) => any;
        • The oninit hook is called before a vnode is touched by the virtual DOM engine.

        method onremove

        onremove: (
        this: _NoLifecycle<this & State>,
        vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>
        ) => any;
        • The onremove hook is called before a DOM element is removed from the document.

        method onupdate

        onupdate: (
        this: _NoLifecycle<this & State>,
        vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>
        ) => any;
        • The onupdate hook is called after a DOM element is updated, while attached to the document.

        method view

        view: (
        this: _NoLifecycle<this & State>,
        vnode: Vnode<Attrs, _NoLifecycle<this & State>>
        ) => Children | null | void;
        • Creates a view out of virtual elements.

        interface CVnode

        interface CVnode<A = {}> extends Vnode<A, ClassComponent<A>> {}

          interface CVnodeDOM

          interface CVnodeDOM<A = {}> extends VnodeDOM<A, ClassComponent<A>> {}

            interface Hyperscript

            interface Hyperscript {}

              method fragment

              fragment: (
              attrs: CommonAttributes<any, any> & { [key: string]: any },
              children: ChildArrayOrPrimitive
              ) => Vnode<any, any>;
              • Creates a fragment virtual element (Vnode).

              method trust

              trust: (html: string) => Vnode<any, any>;
              • Turns an HTML string into a virtual element (Vnode). Do not use trust on unsanitized user input.

              call signature

              <Attrs, State>(
              component: ComponentTypes<Attrs, State>,
              attributes: Attrs & CommonAttributes<Attrs, State>,
              ...args: Children[]
              ): Vnode<Attrs, State>;
              • Creates a virtual element (Vnode).

              call signature

              (selector: string, attributes: Attributes, ...children: Children[]): Vnode<
              any,
              any
              >;
              • Creates a virtual element (Vnode).

              call signature

              <Attrs, State>(
              component: ComponentTypes<Attrs, State>,
              ...args: Children[]
              ): Vnode<Attrs, State>;
              • Creates a virtual element (Vnode).

              call signature

              (selector: string, ...children: Children[]): Vnode<any, any>;
              • Creates a virtual element (Vnode).

              interface JsonpOptions

              interface JsonpOptions {}

                property background

                background?: boolean | undefined;
                • If false, redraws mounted components upon completion of the request. If true, it does not.

                property body

                body?: any;
                • The data to be serialized into the request body.

                property callbackKey

                callbackKey?: string | undefined;
                • The name of the querystring parameter name that specifies the callback name.

                property callbackName

                callbackName?: string | undefined;
                • The name of the function that will be called as the callback.

                property params

                params?: { [id: string]: any } | undefined;
                • The data to be interpolated into the URL and serialized into the querystring.

                property type

                type?: new (o: any) => any;
                • A constructor to be applied to each object in the response.

                interface ParamsRec

                interface ParamsRec {}

                  index signature

                  [key: string]: string | number | boolean | null | undefined | Params;

                    interface Redraw

                    interface Redraw {}

                      method sync

                      sync: () => void;
                      • Manually triggers a synchronous redraw of mounted components.

                      call signature

                      (): void;
                      • Manually triggers an asynchronous redraw of mounted components.

                      interface RequestOptions

                      interface RequestOptions<T> {}

                        property async

                        async?: boolean | undefined;
                        • Whether the request should be asynchronous. Defaults to true.

                        property background

                        background?: boolean | undefined;
                        • If false, redraws mounted components upon completion of the request. If true, it does not.

                        property body

                        body?:
                        | (XMLHttpRequest['send'] extends (x: infer R) => any ? R : never)
                        | (object & { [id: string]: any })
                        | undefined;
                        • The data to be serialized into the request body.

                        property headers

                        headers?: { [key: string]: string } | undefined;
                        • Headers to append to the request before sending it.

                        property method

                        method?: string | undefined;
                        • The HTTP method to use.

                        property params

                        params?: { [key: string]: any } | undefined;
                        • The data to be interpolated into the URL and serialized into the querystring.

                        property password

                        password?: string | undefined;
                        • A password for HTTP authorization.

                        property responseType

                        responseType?:
                        | ''
                        | 'arraybuffer'
                        | 'blob'
                        | 'document'
                        | 'json'
                        | 'text'
                        | undefined;
                        • The expected type of the response, as a legal value of XMLHttpRequest.responseType.

                        property timeout

                        timeout?: number | undefined;
                        • Milliseconds a request can take before automatically being terminated.

                        property type

                        type?: new (o: any) => any;
                        • A constructor to be applied to each object in the response.

                        property useBody

                        useBody?: boolean | undefined;
                        • Force the use of the HTTP body section for data in GET requests when set to true, or the use of querystring for other HTTP methods when set to false. Defaults to false for GET requests and true for other methods.

                        property user

                        user?: string | undefined;
                        • A username for HTTP authorization.

                        property withCredentials

                        withCredentials?: boolean | undefined;
                        • Whether to send cookies to 3rd party domains.

                        method config

                        config: (xhr: XMLHttpRequest, options: this) => XMLHttpRequest | void;
                        • Exposes the underlying XMLHttpRequest object for low-level configuration.

                        method deserialize

                        deserialize: (data: string) => T;
                        • A deserialization method to be applied to the response. Defaults to a small wrapper around JSON.parse that returns null for empty responses.

                        method extract

                        extract: (xhr: XMLHttpRequest, options: this) => T;
                        • A hook to specify how the XMLHttpRequest response should be read. Useful for reading response headers and cookies. Defaults to a function that returns xhr.responseText

                        method serialize

                        serialize: (data: any) => any;
                        • A serialization method to be applied to data. Defaults to JSON.stringify, or if options.data is an instance of FormData, defaults to the identity function.

                        interface Route

                        interface Route {}
                          Link: Component<RouteLinkAttrs>;
                          • This Component renders a link <a href> that will use the current routing strategy

                          property prefix

                          prefix: string;
                          • Defines a router prefix which is a fragment of the URL that dictates the underlying strategy used by the router.

                          method get

                          get: () => string;
                          • Returns the last fully resolved routing path, without the prefix.

                          method param

                          param: { (name: string): string; (): any };
                          • Returns the named parameter value from the current route.

                          • Gets all route parameters.

                          method set

                          set: (route: string, data?: any, options?: RouteOptions) => void;
                          • Redirects to a matching route or to the default route if no matching routes can be found.

                          call signature

                          (element: Element, defaultRoute: string, routes: RouteDefs): void;
                          • Creates application routes and mounts Components and/or RouteResolvers to a DOM element.

                          interface RouteDefs

                          interface RouteDefs {}
                          • This represents a key-value mapping linking routes to components.

                          index signature

                          [url: string]: ComponentTypes<any, any> | RouteResolver<any, any>;
                          • The key represents the route. The value represents the corresponding component.

                          interface RouteLinkAttrs

                          interface RouteLinkAttrs extends Attributes {}

                            property href

                            href: string;

                              property options

                              options?: RouteOptions | undefined;

                                property selector

                                selector?: string | ComponentTypes<any> | undefined;

                                  interface RouteOptions

                                  interface RouteOptions {}

                                    property replace

                                    replace?: boolean | undefined;
                                    • Routing parameters. If path has routing parameter slots, the properties of this object are interpolated into the path string.

                                    property state

                                    state?: any;
                                    • The state object to pass to the underlying history.pushState / history.replaceState call.

                                    property title

                                    title?: string | undefined;
                                    • The title string to pass to the underlying history.pushState / history.replaceState call.

                                    interface RouteResolver

                                    interface RouteResolver<Attrs = {}, State = {}> {}

                                      method onmatch

                                      onmatch: (
                                      this: this,
                                      args: Attrs,
                                      requestedPath: string,
                                      route: string
                                      ) => ComponentTypes<any, any> | Promise<any> | void;
                                      • The onmatch hook is called when the router needs to find a component to render.

                                      method render

                                      render: (this: this, vnode: Vnode<Attrs, State>) => Children;
                                      • The render method is called on every redraw for a matching route.

                                      interface Static

                                      interface Static extends Hyperscript {}

                                        property jsonp

                                        jsonp: typeof jsonp;

                                          property mount

                                          mount: typeof mount;

                                            property redraw

                                            redraw: Redraw;

                                              property render

                                              render: typeof render;

                                                property request

                                                request: typeof request;

                                                  property route

                                                  route: Route;

                                                    method buildPathname

                                                    buildPathname: (template: string, params?: Params) => string;
                                                    • Build path name

                                                    method buildQueryString

                                                    buildQueryString: (values: Params) => string;
                                                    • Turns the key/value pairs of an object into a string of the form: a=1&b=2

                                                    method parsePathname

                                                    parsePathname: (url: string) => { path: string; params: Params };
                                                    • Parse path name

                                                    method parseQueryString

                                                    parseQueryString: (queryString: string) => Params;
                                                    • Returns an object with key/value pairs parsed from a string of the form: ?a=1&b=2

                                                    interface Vnode

                                                    interface Vnode<Attrs = {}, State = {}> {}
                                                    • Virtual DOM nodes, or vnodes, are Javascript objects that represent an element (or parts of the DOM).

                                                    property attrs

                                                    attrs: Attrs;
                                                    • A hashmap of DOM attributes, events, properties and lifecycle methods.

                                                    property children

                                                    children?: ChildArrayOrPrimitive | undefined;
                                                    • In most vnode types, the children property is an array of vnodes. For text and trusted HTML vnodes, The children property is either a string, a number or a boolean.

                                                    property key

                                                    key?: string | number | undefined;
                                                    • The value used to map a DOM element to its respective item in an array of data.

                                                    property state

                                                    state: State;
                                                    • An object that is persisted between redraws. In component vnodes, state is a shallow clone of the component object.

                                                    property tag

                                                    tag: string | ComponentTypes<Attrs, State>;
                                                    • The nodeName of a DOM element. It may also be the string [ if a vnode is a fragment, # if it's a text vnode, or < if it's a trusted HTML vnode. Additionally, it may be a component.

                                                    property text

                                                    text?: string | number | boolean | undefined;
                                                    • This is used instead of children if a vnode contains a text node as its only child. This is done for performance reasons. Component vnodes never use the text property even if they have a text node as their only child.

                                                    interface VnodeDOM

                                                    interface VnodeDOM<Attrs = {}, State = {}> extends Vnode<Attrs, State> {}

                                                      property dom

                                                      dom: Element;
                                                      • Points to the element that corresponds to the vnode.

                                                      property domSize

                                                      domSize?: number | undefined;
                                                      • This defines the number of DOM elements that the vnode represents (starting from the element referenced by the dom property).

                                                      Type Aliases

                                                      type Child

                                                      type Child = Vnode<any, any> | string | number | boolean | null | undefined;

                                                        type ChildArrayOrPrimitive

                                                        type ChildArrayOrPrimitive = ChildArray | string | number | boolean;

                                                          type Children

                                                          type Children = Child | ChildArray;

                                                            type ClosureComponent

                                                            type ClosureComponent<A = {}> = FactoryComponent<A>;
                                                            • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Any function that returns an object with a view method can be used as a Mithril component. Components can be consumed via the m() utility.

                                                            type Comp

                                                            type Comp<Attrs = {}, State = {}> = _NoLifecycle<State> &
                                                            Component<Attrs, _NoLifecycle<State>>;
                                                            • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Any Javascript object that has a view method is a Mithril component. Components can be consumed via the m() utility.

                                                            type ComponentTypes

                                                            type ComponentTypes<A = {}, S = {}> =
                                                            | Component<A, S>
                                                            | { new (vnode: CVnode<A>): ClassComponent<A> }
                                                            | FactoryComponent<A>;
                                                            • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Components can be consumed via the m() utility.

                                                            type FactoryComponent

                                                            type FactoryComponent<A = {}> = (vnode: Vnode<A>) => Component<A>;
                                                            • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Any function that returns an object with a view method can be used as a Mithril component. Components can be consumed via the m() utility.

                                                            type Params

                                                            type Params = object & ParamsRec;

                                                              Namespaces

                                                              namespace global

                                                              namespace global {}

                                                                namespace global.JSX

                                                                namespace global.JSX {}

                                                                  interface Element

                                                                  interface Element extends Mithril.Vnode {}

                                                                    interface IntrinsicAttributes

                                                                    interface IntrinsicAttributes extends Mithril.Attributes {}

                                                                      interface IntrinsicClassAttributes

                                                                      interface IntrinsicClassAttributes extends Mithril.Attributes {}

                                                                        interface IntrinsicElements

                                                                        interface IntrinsicElements {}

                                                                          property '['

                                                                          '[': Mithril.Attributes;

                                                                            property a

                                                                            a: Mithril.Attributes;

                                                                              property abbr

                                                                              abbr: Mithril.Attributes;

                                                                                property address

                                                                                address: Mithril.Attributes;

                                                                                  property animate

                                                                                  animate: Mithril.Attributes;

                                                                                    property animateMotion

                                                                                    animateMotion: Mithril.Attributes;

                                                                                      property animateTransform

                                                                                      animateTransform: Mithril.Attributes;

                                                                                        property area

                                                                                        area: Mithril.Attributes;

                                                                                          property article

                                                                                          article: Mithril.Attributes;

                                                                                            property aside

                                                                                            aside: Mithril.Attributes;

                                                                                              property audio

                                                                                              audio: Mithril.Attributes;

                                                                                                property b

                                                                                                b: Mithril.Attributes;

                                                                                                  property base

                                                                                                  base: Mithril.Attributes;

                                                                                                    property bdi

                                                                                                    bdi: Mithril.Attributes;

                                                                                                      property bdo

                                                                                                      bdo: Mithril.Attributes;

                                                                                                        property big

                                                                                                        big: Mithril.Attributes;

                                                                                                          property blockquote

                                                                                                          blockquote: Mithril.Attributes;

                                                                                                            property body

                                                                                                            body: Mithril.Attributes;

                                                                                                              property br

                                                                                                              br: Mithril.Attributes;

                                                                                                                property button

                                                                                                                button: Mithril.Attributes;

                                                                                                                  property canvas

                                                                                                                  canvas: Mithril.Attributes;

                                                                                                                    property caption

                                                                                                                    caption: Mithril.Attributes;

                                                                                                                      property circle

                                                                                                                      circle: Mithril.Attributes;

                                                                                                                        property cite

                                                                                                                        cite: Mithril.Attributes;

                                                                                                                          property clipPath

                                                                                                                          clipPath: Mithril.Attributes;

                                                                                                                            property code

                                                                                                                            code: Mithril.Attributes;

                                                                                                                              property col

                                                                                                                              col: Mithril.Attributes;

                                                                                                                                property colgroup

                                                                                                                                colgroup: Mithril.Attributes;

                                                                                                                                  property data

                                                                                                                                  data: Mithril.Attributes;

                                                                                                                                    property datalist

                                                                                                                                    datalist: Mithril.Attributes;

                                                                                                                                      property dd

                                                                                                                                      dd: Mithril.Attributes;

                                                                                                                                        property defs

                                                                                                                                        defs: Mithril.Attributes;

                                                                                                                                          property del

                                                                                                                                          del: Mithril.Attributes;

                                                                                                                                            property desc

                                                                                                                                            desc: Mithril.Attributes;

                                                                                                                                              property details

                                                                                                                                              details: Mithril.Attributes;

                                                                                                                                                property dfn

                                                                                                                                                dfn: Mithril.Attributes;

                                                                                                                                                  property dialog

                                                                                                                                                  dialog: Mithril.Attributes;

                                                                                                                                                    property div

                                                                                                                                                    div: Mithril.Attributes;

                                                                                                                                                      property dl

                                                                                                                                                      dl: Mithril.Attributes;

                                                                                                                                                        property dt

                                                                                                                                                        dt: Mithril.Attributes;

                                                                                                                                                          property ellipse

                                                                                                                                                          ellipse: Mithril.Attributes;

                                                                                                                                                            property em

                                                                                                                                                            em: Mithril.Attributes;

                                                                                                                                                              property embed

                                                                                                                                                              embed: Mithril.Attributes;

                                                                                                                                                                property feBlend

                                                                                                                                                                feBlend: Mithril.Attributes;

                                                                                                                                                                  property feColorMatrix

                                                                                                                                                                  feColorMatrix: Mithril.Attributes;

                                                                                                                                                                    property feComponentTransfer

                                                                                                                                                                    feComponentTransfer: Mithril.Attributes;

                                                                                                                                                                      property feComposite

                                                                                                                                                                      feComposite: Mithril.Attributes;

                                                                                                                                                                        property feConvolveMatrix

                                                                                                                                                                        feConvolveMatrix: Mithril.Attributes;

                                                                                                                                                                          property feDiffuseLighting

                                                                                                                                                                          feDiffuseLighting: Mithril.Attributes;

                                                                                                                                                                            property feDisplacementMap

                                                                                                                                                                            feDisplacementMap: Mithril.Attributes;

                                                                                                                                                                              property feDistantLight

                                                                                                                                                                              feDistantLight: Mithril.Attributes;

                                                                                                                                                                                property feDropShadow

                                                                                                                                                                                feDropShadow: Mithril.Attributes;

                                                                                                                                                                                  property feFlood

                                                                                                                                                                                  feFlood: Mithril.Attributes;

                                                                                                                                                                                    property feFuncA

                                                                                                                                                                                    feFuncA: Mithril.Attributes;

                                                                                                                                                                                      property feFuncB

                                                                                                                                                                                      feFuncB: Mithril.Attributes;

                                                                                                                                                                                        property feFuncG

                                                                                                                                                                                        feFuncG: Mithril.Attributes;

                                                                                                                                                                                          property feFuncR

                                                                                                                                                                                          feFuncR: Mithril.Attributes;

                                                                                                                                                                                            property feGaussianBlur

                                                                                                                                                                                            feGaussianBlur: Mithril.Attributes;

                                                                                                                                                                                              property feImage

                                                                                                                                                                                              feImage: Mithril.Attributes;

                                                                                                                                                                                                property feMerge

                                                                                                                                                                                                feMerge: Mithril.Attributes;

                                                                                                                                                                                                  property feMergeNode

                                                                                                                                                                                                  feMergeNode: Mithril.Attributes;

                                                                                                                                                                                                    property feMorphology

                                                                                                                                                                                                    feMorphology: Mithril.Attributes;

                                                                                                                                                                                                      property feOffset

                                                                                                                                                                                                      feOffset: Mithril.Attributes;

                                                                                                                                                                                                        property fePointLight

                                                                                                                                                                                                        fePointLight: Mithril.Attributes;

                                                                                                                                                                                                          property feSpecularLighting

                                                                                                                                                                                                          feSpecularLighting: Mithril.Attributes;

                                                                                                                                                                                                            property feSpotLight

                                                                                                                                                                                                            feSpotLight: Mithril.Attributes;

                                                                                                                                                                                                              property feTile

                                                                                                                                                                                                              feTile: Mithril.Attributes;

                                                                                                                                                                                                                property feTurbulence

                                                                                                                                                                                                                feTurbulence: Mithril.Attributes;

                                                                                                                                                                                                                  property fieldset

                                                                                                                                                                                                                  fieldset: Mithril.Attributes;

                                                                                                                                                                                                                    property figcaption

                                                                                                                                                                                                                    figcaption: Mithril.Attributes;

                                                                                                                                                                                                                      property figure

                                                                                                                                                                                                                      figure: Mithril.Attributes;

                                                                                                                                                                                                                        property filter

                                                                                                                                                                                                                        filter: Mithril.Attributes;

                                                                                                                                                                                                                          property footer

                                                                                                                                                                                                                          footer: Mithril.Attributes;

                                                                                                                                                                                                                            property foreignObject

                                                                                                                                                                                                                            foreignObject: Mithril.Attributes;

                                                                                                                                                                                                                              property form

                                                                                                                                                                                                                              form: Mithril.Attributes;

                                                                                                                                                                                                                                property g

                                                                                                                                                                                                                                g: Mithril.Attributes;

                                                                                                                                                                                                                                  property h1

                                                                                                                                                                                                                                  h1: Mithril.Attributes;

                                                                                                                                                                                                                                    property h2

                                                                                                                                                                                                                                    h2: Mithril.Attributes;

                                                                                                                                                                                                                                      property h3

                                                                                                                                                                                                                                      h3: Mithril.Attributes;

                                                                                                                                                                                                                                        property h4

                                                                                                                                                                                                                                        h4: Mithril.Attributes;

                                                                                                                                                                                                                                          property h5

                                                                                                                                                                                                                                          h5: Mithril.Attributes;

                                                                                                                                                                                                                                            property h6

                                                                                                                                                                                                                                            h6: Mithril.Attributes;

                                                                                                                                                                                                                                              property head

                                                                                                                                                                                                                                              head: Mithril.Attributes;

                                                                                                                                                                                                                                                property header

                                                                                                                                                                                                                                                header: Mithril.Attributes;

                                                                                                                                                                                                                                                  property hgroup

                                                                                                                                                                                                                                                  hgroup: Mithril.Attributes;

                                                                                                                                                                                                                                                    property hr

                                                                                                                                                                                                                                                    hr: Mithril.Attributes;

                                                                                                                                                                                                                                                      property html

                                                                                                                                                                                                                                                      html: Mithril.Attributes;

                                                                                                                                                                                                                                                        property i

                                                                                                                                                                                                                                                        i: Mithril.Attributes;

                                                                                                                                                                                                                                                          property iframe

                                                                                                                                                                                                                                                          iframe: Mithril.Attributes;

                                                                                                                                                                                                                                                            property image

                                                                                                                                                                                                                                                            image: Mithril.Attributes;

                                                                                                                                                                                                                                                              property img

                                                                                                                                                                                                                                                              img: Mithril.Attributes;

                                                                                                                                                                                                                                                                property input

                                                                                                                                                                                                                                                                input: Mithril.Attributes;

                                                                                                                                                                                                                                                                  property ins

                                                                                                                                                                                                                                                                  ins: Mithril.Attributes;

                                                                                                                                                                                                                                                                    property kbd

                                                                                                                                                                                                                                                                    kbd: Mithril.Attributes;

                                                                                                                                                                                                                                                                      property keygen

                                                                                                                                                                                                                                                                      keygen: Mithril.Attributes;

                                                                                                                                                                                                                                                                        property label

                                                                                                                                                                                                                                                                        label: Mithril.Attributes;

                                                                                                                                                                                                                                                                          property legend

                                                                                                                                                                                                                                                                          legend: Mithril.Attributes;

                                                                                                                                                                                                                                                                            property li

                                                                                                                                                                                                                                                                            li: Mithril.Attributes;

                                                                                                                                                                                                                                                                              property line

                                                                                                                                                                                                                                                                              line: Mithril.Attributes;

                                                                                                                                                                                                                                                                                property linearGradient

                                                                                                                                                                                                                                                                                linearGradient: Mithril.Attributes;
                                                                                                                                                                                                                                                                                  link: Mithril.Attributes;

                                                                                                                                                                                                                                                                                    property main

                                                                                                                                                                                                                                                                                    main: Mithril.Attributes;

                                                                                                                                                                                                                                                                                      property map

                                                                                                                                                                                                                                                                                      map: Mithril.Attributes;

                                                                                                                                                                                                                                                                                        property mark

                                                                                                                                                                                                                                                                                        mark: Mithril.Attributes;

                                                                                                                                                                                                                                                                                          property marker

                                                                                                                                                                                                                                                                                          marker: Mithril.Attributes;

                                                                                                                                                                                                                                                                                            property mask

                                                                                                                                                                                                                                                                                            mask: Mithril.Attributes;

                                                                                                                                                                                                                                                                                              property menu

                                                                                                                                                                                                                                                                                              menu: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                property menuitem

                                                                                                                                                                                                                                                                                                menuitem: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                  property meta

                                                                                                                                                                                                                                                                                                  meta: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                    metadata: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                      property meter

                                                                                                                                                                                                                                                                                                      meter: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                        property mpath

                                                                                                                                                                                                                                                                                                        mpath: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                          property nav

                                                                                                                                                                                                                                                                                                          nav: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                            property noindex

                                                                                                                                                                                                                                                                                                            noindex: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                              property noscript

                                                                                                                                                                                                                                                                                                              noscript: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                property object

                                                                                                                                                                                                                                                                                                                object: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                  property ol

                                                                                                                                                                                                                                                                                                                  ol: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                    property optgroup

                                                                                                                                                                                                                                                                                                                    optgroup: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                      property option

                                                                                                                                                                                                                                                                                                                      option: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                        property output

                                                                                                                                                                                                                                                                                                                        output: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                          property p

                                                                                                                                                                                                                                                                                                                          p: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                            property param

                                                                                                                                                                                                                                                                                                                            param: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                                                                              path: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                property pattern

                                                                                                                                                                                                                                                                                                                                pattern: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                  property picture

                                                                                                                                                                                                                                                                                                                                  picture: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                    property polygon

                                                                                                                                                                                                                                                                                                                                    polygon: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                      property polyline

                                                                                                                                                                                                                                                                                                                                      polyline: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                        property pre

                                                                                                                                                                                                                                                                                                                                        pre: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                          property progress

                                                                                                                                                                                                                                                                                                                                          progress: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                            property q

                                                                                                                                                                                                                                                                                                                                            q: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                              property radialGradient

                                                                                                                                                                                                                                                                                                                                              radialGradient: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                property rect

                                                                                                                                                                                                                                                                                                                                                rect: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                  property rp

                                                                                                                                                                                                                                                                                                                                                  rp: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                    property rt

                                                                                                                                                                                                                                                                                                                                                    rt: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                      property ruby

                                                                                                                                                                                                                                                                                                                                                      ruby: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                        property s

                                                                                                                                                                                                                                                                                                                                                        s: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                          property samp

                                                                                                                                                                                                                                                                                                                                                          samp: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                            property script

                                                                                                                                                                                                                                                                                                                                                            script: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                              property section

                                                                                                                                                                                                                                                                                                                                                              section: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                property select

                                                                                                                                                                                                                                                                                                                                                                select: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                  property small

                                                                                                                                                                                                                                                                                                                                                                  small: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                                                    source: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                      property span

                                                                                                                                                                                                                                                                                                                                                                      span: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                        property stop

                                                                                                                                                                                                                                                                                                                                                                        stop: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                          property strong

                                                                                                                                                                                                                                                                                                                                                                          strong: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                            property style

                                                                                                                                                                                                                                                                                                                                                                            style: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                              property sub

                                                                                                                                                                                                                                                                                                                                                                              sub: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                property summary

                                                                                                                                                                                                                                                                                                                                                                                summary: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                  property sup

                                                                                                                                                                                                                                                                                                                                                                                  sup: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                    property svg

                                                                                                                                                                                                                                                                                                                                                                                    svg: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                      property switch

                                                                                                                                                                                                                                                                                                                                                                                      switch: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                        property symbol

                                                                                                                                                                                                                                                                                                                                                                                        symbol: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                          property table

                                                                                                                                                                                                                                                                                                                                                                                          table: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                            property tbody

                                                                                                                                                                                                                                                                                                                                                                                            tbody: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                              property td

                                                                                                                                                                                                                                                                                                                                                                                              td: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                property template

                                                                                                                                                                                                                                                                                                                                                                                                template: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                  property text

                                                                                                                                                                                                                                                                                                                                                                                                  text: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                    property textarea

                                                                                                                                                                                                                                                                                                                                                                                                    textarea: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                      property textPath

                                                                                                                                                                                                                                                                                                                                                                                                      textPath: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                        property tfoot

                                                                                                                                                                                                                                                                                                                                                                                                        tfoot: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                          property th

                                                                                                                                                                                                                                                                                                                                                                                                          th: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                            property thead

                                                                                                                                                                                                                                                                                                                                                                                                            thead: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                              property time

                                                                                                                                                                                                                                                                                                                                                                                                              time: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                property title

                                                                                                                                                                                                                                                                                                                                                                                                                title: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                  property tr

                                                                                                                                                                                                                                                                                                                                                                                                                  tr: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                    property track

                                                                                                                                                                                                                                                                                                                                                                                                                    track: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                      property tspan

                                                                                                                                                                                                                                                                                                                                                                                                                      tspan: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                        property u

                                                                                                                                                                                                                                                                                                                                                                                                                        u: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                          property ul

                                                                                                                                                                                                                                                                                                                                                                                                                          ul: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                            property use

                                                                                                                                                                                                                                                                                                                                                                                                                            use: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                              property var

                                                                                                                                                                                                                                                                                                                                                                                                                              var: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                property video

                                                                                                                                                                                                                                                                                                                                                                                                                                video: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property view

                                                                                                                                                                                                                                                                                                                                                                                                                                  view: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property wbr

                                                                                                                                                                                                                                                                                                                                                                                                                                    wbr: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property webview

                                                                                                                                                                                                                                                                                                                                                                                                                                      webview: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                        No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                        No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/mithril.

                                                                                                                                                                                                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/mithril)
                                                                                                                                                                                                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/@types/mithril"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>