/**
 * The base class for all components in the library.  This enables each module
 * to guarantee certain variables will be present through inheritance.
 *
 * The values of these variables are computed automatically for any component
 * that inherits from BaseComponent (controlled by props).  This class inherits
 * from `React.PureComponent` to take advantage of `shouldComponentUpdate`
 * shallow object comparison when computing styles based on props/state.
 *
 * #### Examples:
 *
 * ```javascript
 * import {BaseComponent} from '../shared';
 * ...
 * export class XYZ extends BaseComponent<Props, State> {
 *    ...
 * }
 *
 * ...
 *
 * <XYZ sizing={Sizing.xxsmall} location={Location.topRight} />
 * ```
 *
 * In the example above the `sizing` and `location` would be computed
 * automatically for the given values.  These values are then available to the
 * child class to use in building the component using these styles.
 *
 * @module BaseComponent
 */
import { PureComponent } from "react";
import { DefaultTheme } from "styled-components";
import { Keys } from "util.keys";
import { KeyHandler, KeyMap } from "./keybinding";
import { BaseProps } from "./props";
import { FontStyle, Sizes, Sizing, Styling } from "./sizing";
export declare const baseZIndex: number;
export declare const defaultSize: number;
export declare let sizes: Sizes;
export interface BaseOptions {
    namespaceRoot?: string;
}
export interface RenderOptions {
    noclassnameupdate?: boolean;
}
export declare abstract class BaseComponent<P extends BaseProps, S> extends PureComponent<P, S> {
    private _className;
    private _debug;
    private _debugCreate;
    private _debugRender;
    private _defaultClassName;
    static defaultStyles: any;
    private _id;
    protected _keys: Keys;
    protected _keyHandler: KeyHandler;
    protected _keyMap: KeyMap;
    private _name;
    protected _options: BaseOptions;
    state: S;
    constructor(defaultClassName: string, cls: any, props: P, state?: S, options?: BaseOptions);
    readonly className: string;
    readonly defaultClassName: string;
    readonly defaultSize: number;
    /**
     * @return {string} the unique id value that was generated for this component
     */
    readonly id: string;
    initialState: S;
    readonly keyHandler: KeyHandler;
    readonly keyMap: KeyMap;
    readonly keys: Keys;
    readonly name: string;
    readonly theme: DefaultTheme;
    /**
     * The input mappings structure is the name of the keyboaard mapping
     * property and the associated function handler pointer.  These are
     * mapped to their respective KeyMap and Handler objects.  These can
     * then be used by the HotKeys object in a component to map a
     * keyboard handler to that component.  The format of the input
     * object is:
     *
     *     mappings = {
     *         "kbActivate": this.handler
     *     }
     *
     * The key name in the interface must match the prop name for that
     * key binding.  See the <Button>
     *
     * @param mappings {KeyHanlder} - an object of key names and their
     * associated function mappings.
     */
    protected buildKeyMap(mappings: KeyHandler): void;
    protected debug(...args: any[]): void;
    static font(sizing?: Sizing): FontStyle;
    static fontSize(sizing?: Sizing): number;
    static fontSizePX(sizing?: Sizing, scale?: number): string;
    static fontSizeREM(sizing?: Sizing, scale?: number): string;
    /**
     * Each component has a getDerivedStateFromProps call.  This method is used
     * by that call to set state properties that are common to all components.  It
     * is checked for changes before the update will go through (so updates can be
     * avoided when not needed).  The method contains a 3rd parameter flag to
     * force this to return a new object instead of null.
     * @param props {P} - the set of props that will be updated
     * @param state {S} - the current state object when called
     * @param forceUpdate=false {boolean} - force the state to return an object for
     * update
     * @return {S} a new, mutated state that will be merged into the current state
     */
    static getDerivedStateFromProps(props: any, state: any, forceUpdate?: boolean): any;
    static lineHeightPX(sizing?: Sizing): string;
    /**
     * Takes the given base Sizing and determines what the next size
     * in the list would be.  e.g. if current size is *normal*, then
     * the next size would be *large*.
     * @param sizing {Sizing} an optional parameter that allows for overriding
     * the default sizing when the class is created.
     * @returns a reference to a `Styling` object.  This contains
     * font type/size, box, and border information.
     */
    static next(sizing?: Sizing): Styling;
    /**
     * Takes the given base Sizing and determines what the previous size
     * in the list would be.  e.g. if current size is *normal*, then
     * the previous size would be *small*.
     * @param sizing {Sizing} an optional parameter that allows for overriding
     * the default sizing when the class is created.
     * @returns a reference to a `Styling` object.  This contains font type/size,
     * box, and border information.
     */
    static prev(sizing?: Sizing): Styling;
    /**
     * Called by the child render methods as the first call.  This is used to
     * update base items before the child class performs its render operation.
     */
    render(options?: RenderOptions): any;
    /**
     * Checks the previous and incoming props for sizing changes.  If the control
     * has children, then they are each updated with the sizing change.
     * @param props {P} the previous properties on the component
     * @param nextPrpos {P} the new properties for the component
     * @return {any} a new set of children if the size has changed.  If the props
     * do not have chilren, then NULL is returned.
     */
    protected resizeChildren(props: P, nextProps: P): any;
    static styling(sizing?: Sizing): Styling;
    /**
     * Returns the Sizing enum value associated with the given sizing.
     * @param sizing {Sizing} an optional parameter that allows for overriding
     * the default sizing when the class is created.
     * @returns a refernce to a Sizing enum value.
     */
    static type(sizing?: Sizing): Sizing;
    /**
     * Used in each render() call for a component to properly setup up the
     * className property used in that component
     * @param classNames=null {string|string[]} - Allows the render method
     * to add additional classes when building the default className
     * @return a string that represents the current className string for
     * a component.
     */
    protected updateClassName(classNames?: string | string[]): string;
}