preact

constructor(props?: {}, context?: any);

base?: Element | Text;

context: any;

static contextType?: Context<any>;

static defaultProps?: any;

static displayName?: string;

props: Readonly<Attributes & { children?: ComponentChildren; ref?: Ref<any> }>;

state: Readonly<S>;

forceUpdate: (callback?: () => void) => void;

static getDerivedStateFromError: (error: any) => object | null;

static getDerivedStateFromProps: (
    props: Readonly<object>,
    state: Readonly<object>
) => object | null;

abstract render: (
    props?: RenderableProps<P>,
    state?: Readonly<S>,
    context?: any
) => ComponentChildren;

setState: <K extends keyof S>(
    state:
        | ((
              prevState: Readonly<S>,
              props: Readonly<P>
          ) => Pick<S, K> | Partial<S> | null)
        | Pick<S, K>
        | Partial<S>,
    callback?: () => void
) => void;

jsx?: boolean | undefined;

key?: Key | undefined;

ref?: Ref<T>;

componentDidCatch: (error: any, errorInfo: ErrorInfo) => void;

componentDidMount: () => void;

componentDidUpdate: (
    previousProps: Readonly<P>,
    previousState: Readonly<S>,
    snapshot: any
) => void;

componentWillMount: () => void;

componentWillReceiveProps: (nextProps: Readonly<P>, nextContext: any) => void;

componentWillUnmount: () => void;

componentWillUpdate: (
    nextProps: Readonly<P>,
    nextState: Readonly<S>,
    nextContext: any
) => void;

getChildContext: () => object;

getSnapshotBeforeUpdate: (oldProps: Readonly<P>, oldState: Readonly<S>) => any;

shouldComponentUpdate: (
    nextProps: Readonly<P>,
    nextState: Readonly<S>,
    nextContext: any
) => boolean;

contextType?: Context<any>;

defaultProps?: Partial<P>;

displayName?: string;

getDerivedStateFromError: (error: any) => Partial<S> | null;

getDerivedStateFromProps: (
    props: Readonly<P>,
    state: Readonly<S>
) => Partial<S> | null;

new (props: P, context?: any): Component<P, S>;

readonly childNodes: ArrayLike<ContainerNode>;

readonly firstChild: ContainerNode | null;

readonly nodeType: number;

readonly parentNode: ContainerNode | null;

appendChild: (node: ContainerNode) => ContainerNode;

contains: (other: ContainerNode | null) => boolean;

insertBefore: (
    node: ContainerNode,
    child: ContainerNode | null
) => ContainerNode;

removeChild: (child: ContainerNode) => ContainerNode;

Consumer: Consumer<T>;

displayName?: string;

Provider: Provider<T>;

componentStack?: string;

defaultProps?: Partial<P> | undefined;

displayName?: string;

(props: RenderableProps<P>, context?: any): ComponentChildren;

attr: (name: string, value: any) => string | void;

debounceRendering: (cb: () => void) => void;

diffed: (vnode: VNode) => void;

event: (e: Event) => any;

requestAnimationFrame: (callback: () => void) => void;

unmount: (vnode: VNode) => void;

useDebugValue: (value: string | number) => void;

vnode: (vnode: VNode) => void;

children?: ComponentChildren;

dangerouslySetInnerHTML?: {
    __html: string;
};

endTime?: number;

key: Key;

props: P & { children: ComponentChildren };

ref?: Ref<any> | null;

startTime?: number;

type: ComponentType<P> | string;