/**
 * Represents a vanilla JavaScript Component. This is a lightweight version of
 * what you'd find in most modern web application libraries. It provides a
 * React-inspired API.
 */
export default class Component {
    static get observedAttributes(): string[];
    /**
     * Adds the Component middleware, but first unregisters any previous
     * Component middleware.
     *
     * @returns {void}
     */
    static subscribeMiddleware(): void;
    /**
     * Removes the Component middleware and clears the internal caches.
     *
     * @returns {void}
     */
    static unsubscribeMiddleware(): void;
    /**
     * Allow tests to unbind this task, you would not typically need to do this in
     * a web application, as this code loads once and is not reloaded.
     *
     * @type {Function | null}
     */
    static [$$unsubscribe]: Function | null;
    /**
     * Creates a lightweight stateful JavaScript component. Takes the static
     * default props and applies them to the incoming initial props.
     *
     * @param {Props} initialProps
     */
    constructor(initialProps: Props);
    props: Props;
    /**
     * @param {Props} props
     * @param {State} state
     *
     * @returns {VTree[] | VTree | undefined}
     */
    render(props: Props, state: State): VTree[] | VTree | undefined;
    /**
     * Changes the component state synchronously by shallow merging the incoming
     * state into the previous state. Rendering will then be scheduled to the
     * next reachable tick. If this is called multiple times on a single tick
     * all that will happen is the state will be updated by no rendering will
     * occur until the next tick.
     *
     * You can await this method to know when rendering has completed.
     *
     * @param {State} state
     */
    setState(state: State): any;
    /** @type {State} */
    state: State;
    /**
     * Schedule a render to happen, bypassing shouldComponentUpdate. Bound to the
     * same tick logic as setState, allowing this to be called as many times as
     * you want.
     */
    forceUpdate(): any;
    connectedCallback(): void;
    disconnectedCallback(): void;
    attributeChangedCallback(): void;
    /**
     * @param {Props} props
     * @param {State} state
     *
     * @returns {boolean}
     */
    shouldComponentUpdate(props: Props, state: State): boolean;
    componentWillMount(): void;
    componentDidMount(): void;
    /**
     * @param {Props} props
     * @param {State} state
     */
    componentWillReceiveProps(props: Props, state: State): void;
    /**
     * @param {Props} props
     * @param {State} state
     *
     * @returns {void}
     */
    componentDidUpdate(props: Props, state: State): void;
    componentWillUnmount(): void;
    /** @type {'web'|'class'} */
    [$$type]: 'web' | 'class';
    /** @type {VTree | null} */
    [$$vTree]: VTree | null;
    /** @type {Function[]} */
    [$$hooks]: Function[];
    /**
     * Stateful render. Used when a component changes and needs to re-render
     * itself. This is triggered on `setState` and `forceUpdate` calls.
     *
     * @return {Promise<Transaction> | undefined}
     */
    [$$render](): Promise<Transaction> | undefined;
}
import { Props } from "./util/types";
import { State } from "./util/types";
import { VTree } from "./util/types";
import { $$type } from "./util/symbols";
import { $$vTree } from "./util/symbols";
import { $$hooks } from "./util/symbols";
import { $$render } from "./util/symbols";
import { Transaction } from "./util/types";
import { $$unsubscribe } from "./util/symbols";
