import type { Rule } from 'eslint';
interface JSXAttributeValue {
    type: string;
    value?: unknown;
    expression?: {
        type: string;
        value?: unknown;
        expressions?: unknown[];
        quasis?: {
            value: {
                cooked: string | null;
            };
        }[];
    };
}
interface JSXAttribute {
    type: 'JSXAttribute';
    name: {
        type: string;
        name?: string;
    };
    value: JSXAttributeValue | null;
}
interface JSXOpeningElement {
    name: {
        type: string;
        name?: string;
    };
    attributes: (JSXAttribute | {
        type: 'JSXSpreadAttribute';
    })[];
    loc: NonNullable<Rule.Node['loc']>;
    range: [number, number];
}
/**
 * What the package has instead of one raw element: the component the message
 * names, and where one element does more than one job, the others after it.
 * `null` is an element the package has no part for yet.
 */
export interface RawElementPart {
    use: string;
    more?: string;
}
/**
 * The mapping (UIG-7), derived from the package's exports: every interactive
 * element in the HTML standard's list ("interactive content"), plus `<dialog>`,
 * `<form>` and `<progress>`, which have a part here. docs/GATES.md prints it.
 *
 * Not here, on purpose: `<summary>` (it lives inside a `<details>`, which is
 * reported), `<option>`, `<optgroup>` and `<datalist>` (they live inside a
 * `<select>` or beside an input), `<fieldset>` and `<legend>` (a group's frame,
 * no control of its own), and `<img>` without `usemap`, `<hr>`, `<kbd>`, which
 * are not controls. An `<audio>` or `<video>` is a control only with `controls`.
 */
export declare const RAW_ELEMENT_PARTS: Record<string, RawElementPart | null>;
/**
 * An `<input>` is as many controls as its `type`. A type missing from here
 * (text, email, password, url, tel, number, or one the browser does not know)
 * is a text box.
 */
export declare const RAW_INPUT_PARTS: Record<string, RawElementPart | null>;
type Found = {
    report: 'raw';
    element: string;
    part: RawElementPart;
} | {
    report: 'noPart';
    element: string;
} | {
    report: 'clickable';
    element: string;
} | null;
/** What this element is to the rule: a raw element with a part, one with none yet, or none of its business. */
export declare function classify(element: JSXOpeningElement): Found;
/**
 * A raw interactive element in an app, where the package has a part for it
 * (UIG-3 began it with `<button>`; UIG-7 made it every element). A control
 * the app writes itself has a look, a focus ring and keys that nobody else
 * keeps in step with — and it looks nearly right, which is why nobody catches
 * it by eye. Every message names the part to use.
 *
 * An element the package has no part for yet is refused too, with a message
 * that says so: the part is made in the package, not by hand in an app
 * (Katerina, 16 September).
 *
 * A plain element with a press handler (`<div onClick>`) is a control too, and
 * is refused naming `Button` (R5, 25 September); a handler that only stops the
 * click reaching what is behind passes.
 *
 * Only a JSX element written with a lowercase name. `<Button>`,
 * `<Foo.button>` and `createElement('button')` are not this rule's business.
 */
export declare const noRawElement: Rule.RuleModule;
export {};
//# sourceMappingURL=no-raw-element.d.ts.map