@starci/eslint-canon-fe 9.3.0 → 9.4.0

package/dist/control-height.js

@@ -0,0 +1,83 @@
+/** CONTROL-HEIGHT-1: one control height; the app never picks a larger step or mixes steps in one row. */
+import { attributeValue, stringOf } from "./lib/ast.js";
+import { importOf } from "./lib/bindings.js";
+import { defineRule } from "./lib/rule.js";
+const GRAMMAR_ENTRY = /^@starci\/grammar(?:\/(?:common|core|offset-pop))?$/;
+const CONTROLS = new Set(["Button", "IconButton", "Switch", "Input", "SearchField", "Select", "Tabs", "SegmentedControl", "Textarea", "NumberField", "ComboBox"]);
+/** A marketing hero call to action on a landing page is the one place the 48px step is allowed. */
+const LANDING_PATH = /[\\/](?:landing|hero|marketing)[\\/]|(?:Landing|Hero)[^\\/]*[\\/]/;
+/** The default size and its two spellings: the vendor `md` and Grammar's `control` are the same 40px height. */
+const DEFAULT_SIZE = new Set(["md", "control"]);
+/** The Grammar control a JSX name resolves to; a shadowed or foreign component of the same name is not one. */
+const controlOf = (context, name) => {
+    let root = name;
+    const parts = [];
+    while (root.type === "JSXMemberExpression") {
+        parts.unshift(root.property.name);
+        root = root.object;
+    }
+    if (root.type !== "JSXIdentifier")
+        return null;
+    const imported = importOf(context, root);
+    if (!imported || !GRAMMAR_ENTRY.test(imported.source))
+        return null;
+    const role = imported.imported ?? parts.shift();
+    return role !== undefined && parts.length === 0 && CONTROLS.has(role) ? role : null;
+};
+/** The statically authored size of a control: `control` when absent, null when it is dynamic. */
+const sizeOf = (opening) => {
+    const attribute = opening.attributes.find((entry) => entry.type === "JSXAttribute" && entry.name.name === "size");
+    if (!attribute)
+        return "control";
+    const text = stringOf(attributeValue(attribute));
+    if (text === null)
+        return null;
+    return DEFAULT_SIZE.has(text) ? "control" : text;
+};
+/** The Grammar controls a row holds directly, looking through fragments. */
+const rowControls = (context, element) => element.children.flatMap((child) => {
+    if (child.type === "JSXFragment")
+        return rowControls(context, child);
+    if (child.type !== "JSXElement")
+        return [];
+    return controlOf(context, child.openingElement.name) === null ? [] : [child.openingElement];
+});
+const controlHeight = defineRule({
+    meta: { type: "problem", docs: { description: "CONTROL-HEIGHT-1: one 40px control height, no larger step outside a landing hero, no mixed sizes in one row." }, schema: [], messages: {
+            FE_CONTROL_HEIGHT: "FE_CONTROL_HEIGHT: {{detail}} Grammar draws every standalone control at one 40px height; omit size (sm is for a control nested in an item or a dense toolbar, lg only for a landing hero call to action).",
+        } },
+    create(context) {
+        const landing = LANDING_PATH.test(context.filename);
+        const reported = new Set();
+        const report = (node, detail) => {
+            if (reported.has(node))
+                return;
+            reported.add(node);
+            context.report({ node, messageId: "FE_CONTROL_HEIGHT", data: { detail } });
+        };
+        return {
+            JSXOpeningElement(opening) {
+                const role = controlOf(context, opening.name);
+                if (role === null)
+                    return;
+                const size = sizeOf(opening);
+                if (size === "xl" || (size === "lg" && !landing))
+                    report(opening, `${role} size="${size}" is a larger control step than the app chrome allows.`);
+            },
+            "JSXElement, JSXFragment"(element) {
+                const controls = rowControls(context, element);
+                const sizes = controls.map(sizeOf);
+                if (sizes.includes(null) || new Set(sizes).size < 2)
+                    return;
+                const index = sizes.findIndex((size) => size !== sizes[0]);
+                const odd = controls[index];
+                if (odd)
+                    report(odd, "this control sits in a row with controls of another size.");
+            },
+        };
+    },
+});
+/** The one rule of the law. */
+export const rules = { "control-height": controlHeight };
+/** The rule reaches consumers at error. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]));

package/dist/drawing.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The rules that hold the drawing law (the `drawing` slot role: a surface's pure `component.tsx`).
+ *
+ * TWO AXES, AND ONLY ONE IS DRAWN. A surface's `shape` is its SHAPE: a layout the owner approves as
+ * one drawing. A slot's data status (loading, forbidden, error, empty) is not a shape; it is a
+ * status recipe applied per resource, and it is never a drawn shape. Mixing the two is what made
+ * every block ship four hand-drawn variants that disagreed with each other.
+ *
+ * THE PURE HALF TAKES ATOMS. `component.tsx` receives `{ shape?, props, on? }`: `props` is data
+ * (strings, numbers, booleans, arrays, plain objects), `on` is actions whose arguments are data,
+ * and feature composition may also take named `render` callbacks inside `props` to render supplied
+ * blocks. A layout alone also takes `children`, because the router puts the page there.
+ *
+ * ONLY ITS OWN INDEX MAY IMPORT IT. Other tiers use the connected export, so the pure half stays a
+ * private drawing surface that audit can render from a fixture.
+ *
+ * Every rule reads one file. Types imported from elsewhere are trusted as data; only names this
+ * file declares are followed, which is exact for the tree the convention produces and silent,
+ * never wrong, beyond it.
+ */
+import { type Rules, type Recommended } from "./lib/rule.js";
+/** The pure half takes atom data and actions; feature composition may receive named render callbacks. */
+export declare const basePropsAtom: import("./lib/rule.js").Rule<"action" | "tree" | "onData" | "member" | "renamed", []>;
+/** Only the sibling `index.tsx` (and its specs) may reach `component.tsx`; only `X` leaves the folder. */
+export declare const baseImportPair: import("./lib/rule.js").Rule<"reach" | "reexport", []>;
+/** A surface's `XShape` names drawn shapes only: no data status, no open/closed, no status flag. */
+export declare const noDataStatusShape: import("./lib/rule.js").Rule<"status" | "flag", []>;
+/** The rules this law contributes to the plugin. */
+export declare const rules: Rules;
+/** Every FE canon rule is an error; existing debt is fixed before adoption. */
+export declare const recommended: Recommended;

package/dist/drawing.js

@@ -0,0 +1,376 @@
+/**
+ * The rules that hold the drawing law (the `drawing` slot role: a surface's pure `component.tsx`).
+ *
+ * TWO AXES, AND ONLY ONE IS DRAWN. A surface's `shape` is its SHAPE: a layout the owner approves as
+ * one drawing. A slot's data status (loading, forbidden, error, empty) is not a shape; it is a
+ * status recipe applied per resource, and it is never a drawn shape. Mixing the two is what made
+ * every block ship four hand-drawn variants that disagreed with each other.
+ *
+ * THE PURE HALF TAKES ATOMS. `component.tsx` receives `{ shape?, props, on? }`: `props` is data
+ * (strings, numbers, booleans, arrays, plain objects), `on` is actions whose arguments are data,
+ * and feature composition may also take named `render` callbacks inside `props` to render supplied
+ * blocks. A layout alone also takes `children`, because the router puts the page there.
+ *
+ * ONLY ITS OWN INDEX MAY IMPORT IT. Other tiers use the connected export, so the pure half stays a
+ * private drawing surface that audit can render from a fixture.
+ *
+ * Every rule reads one file. Types imported from elsewhere are trusted as data; only names this
+ * file declares are followed, which is exact for the tree the convention produces and silent,
+ * never wrong, beyond it.
+ */
+import { defineRule } from "./lib/rule.js";
+import { classifyImport, roleOfFile } from "./lib/scope.js";
+import { inSplitTier, pureHalf } from "./lib/drawing-scope.js";
+/** Type names that carry a rendered tree rather than data. */
+const NON_ATOM_TYPE = /^(?:ReactNode|ReactElement|ReactPortal|JSX\.Element|Element|ComponentType|FC|FunctionComponent|ElementType|ComponentProps|RenderFunction)$/;
+/** Feature composition's render callbacks return a rendered value and take only data. */
+const RENDER_RESULT_TYPE = /^(?:ReactNode|ReactElement|JSX\.Element)$/;
+const RENDER_PROP_NAME = /^render(?:[A-Z][A-Za-z0-9]*)?$/;
+/** The declared type of a parameter, or undefined. */
+const parameterType = (parameter) => parameter !== undefined && "typeAnnotation" in parameter ? parameter.typeAnnotation?.typeAnnotation : undefined;
+/** The name of a parameter that is a plain identifier, or undefined. */
+const parameterName = (parameter) => ("name" in parameter ? parameter.name : undefined);
+/** The declared type of a member of an object type, or undefined. */
+const memberType = (member) => "typeAnnotation" in member ? member.typeAnnotation?.typeAnnotation : undefined;
+const typeNameOf = (node) => {
+    const name = node?.typeName;
+    if (!name)
+        return "";
+    if (name.type === "Identifier")
+        return name.name;
+    if (name.type === "TSQualifiedName")
+        return `${typeNameOf({ typeName: name.left })}.${name.right.name}`;
+    return "";
+};
+/** Every type this file declares, by name, so references can be followed locally. */
+const collectLocalTypes = (program) => {
+    const types = new Map();
+    const visit = (statement) => {
+        const declaration = statement?.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+        if (declaration?.type === "TSTypeAliasDeclaration")
+            types.set(declaration.id.name, declaration.typeAnnotation);
+        if (declaration?.type === "TSInterfaceDeclaration")
+            types.set(declaration.id.name, declaration.body);
+    };
+    for (const statement of program.body)
+        visit(statement);
+    return types;
+};
+/** The members of an object-shaped type node, following local names and intersections. */
+const membersOf = (node, types, seen = new Set()) => {
+    if (!node)
+        return [];
+    if (node.type === "TSTypeLiteral")
+        return node.members;
+    if (node.type === "TSInterfaceBody")
+        return node.body;
+    if (node.type === "TSIntersectionType")
+        return node.types.flatMap((part) => membersOf(part, types, seen));
+    if (node.type === "TSTypeReference") {
+        const name = typeNameOf(node);
+        if (seen.has(name) || !types.has(name))
+            return [];
+        seen.add(name);
+        return membersOf(types.get(name), types, seen);
+    }
+    return [];
+};
+/** The key a property signature declares. */
+const keyOf = (member) => {
+    const key = "key" in member ? member.key : undefined;
+    return key?.type === "Identifier" ? key.name : key !== undefined && "value" in key ? key.value : undefined;
+};
+// -- DRAWING-1 ----------------------------------------------------------------------------------
+/** The pure half takes atom data and actions; feature composition may receive named render callbacks. */
+export const basePropsAtom = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "A pure `XBase` takes `shape`, atom `props` and `on` actions; feature composition may receive named render callbacks in `props`." },
+        fixable: "code",
+        schema: [],
+        messages: {
+            tree: "`{{path}}` hands a rendered tree (`{{type}}`) into the pure half. Write the child inside `component.tsx` and pass it atoms (ids, strings, flags); a tree handed in cannot be drawn, audited or reused.",
+            action: "`{{path}}` is a function inside `props`. Actions live in `on`; feature composition may receive named `render` callbacks that take atoms and return rendered blocks.",
+            onData: "`on.{{key}}` is not an action. `on` holds functions only; data belongs in `props`.",
+            member: "`{{key}}` is not part of the pure contract. A pure half takes `shape`, `props` and `on`{{children}}.",
+            renamed: "`state` is the retired name of the drawn shape: rename it `shape` (owner ruling fe-shape-not-state).",
+        },
+    },
+    create(context) {
+        const tier = pureHalf(context);
+        if (!tier)
+            return {};
+        let types = new Map();
+        /** Resolve render results locally; an optional empty result does not make data a render prop. */
+        const isRenderResult = (node, seen = new Set()) => {
+            if (!node)
+                return false;
+            if (node.type === "TSUnionType") {
+                const empty = (part) => ["TSNullKeyword", "TSUndefinedKeyword"].includes(part.type)
+                    || part.type === "TSLiteralType" && "value" in part.literal && part.literal.value === null;
+                return node.types.some((part) => isRenderResult(part, new Set(seen)))
+                    && node.types.every((part) => empty(part) || isRenderResult(part, new Set(seen)));
+            }
+            if (node.type !== "TSTypeReference")
+                return false;
+            const name = typeNameOf(node);
+            if (RENDER_RESULT_TYPE.test(name.replace(/^React\./, "")))
+                return true;
+            if (!types.has(name) || seen.has(name))
+                return false;
+            return isRenderResult(types.get(name), new Set(seen).add(name));
+        };
+        const checkRenderCallback = (node, path, allowed) => {
+            if (!allowed || !isRenderResult(node.returnType?.typeAnnotation))
+                return false;
+            for (const parameter of node.params) {
+                checkData(parameterType(parameter), `${path}(${parameterName(parameter) ?? "arg"})`, new Set(), false, true);
+            }
+            return true;
+        };
+        const checkDataReference = (node, path, seen, renderProp, renderParameter) => {
+            const name = typeNameOf(node);
+            if (NON_ATOM_TYPE.test(renderParameter ? name.replace(/^React\./, "") : name)) {
+                context.report({ node, messageId: "tree", data: { path, type: name } });
+                return;
+            }
+            for (const argument of node.typeArguments?.params ?? [])
+                checkData(argument, path, seen, false, renderParameter);
+            if (types.has(name) && !seen.has(name)) {
+                const nextSeen = renderProp || renderParameter ? new Set(seen) : seen;
+                nextSeen.add(name);
+                checkData(types.get(name), path, nextSeen, renderProp, renderParameter);
+            }
+        };
+        const checkDataMember = (member, path, seen, renderParameter) => {
+            const memberPath = `${path}.${String(keyOf(member))}`;
+            const allowsRender = tier !== "blocks" && path === "props" && RENDER_PROP_NAME.test(String(keyOf(member)));
+            if (member.type === "TSMethodSignature") {
+                if (!checkRenderCallback(member, memberPath, allowsRender))
+                    context.report({ node: member, messageId: "action", data: { path: memberPath } });
+            }
+            else if (member.type === "TSPropertySignature") {
+                checkData(memberType(member), memberPath, seen, allowsRender, renderParameter);
+            }
+        };
+        /** Walk a data type: report trees and functions anywhere inside it. */
+        const checkData = (node, path, seen, renderProp = false, renderParameter = false) => {
+            if (!node)
+                return;
+            switch (node.type) {
+                case "TSFunctionType":
+                    if (checkRenderCallback(node, path, renderProp))
+                        return;
+                    context.report({ node, messageId: "action", data: { path } });
+                    return;
+                case "TSTypeReference":
+                    checkDataReference(node, path, seen, renderProp, renderParameter);
+                    return;
+                case "TSUnionType":
+                case "TSIntersectionType":
+                    for (const part of node.types)
+                        checkData(part, path, seen, renderProp, renderParameter);
+                    return;
+                case "TSArrayType":
+                    checkData(node.elementType, path, seen, false, renderParameter);
+                    return;
+                case "TSTypeOperator":
+                    checkData(node.typeAnnotation, path, seen, false, renderParameter);
+                    return;
+                case "TSTypeLiteral":
+                case "TSInterfaceBody":
+                    for (const member of node.type === "TSTypeLiteral" ? node.members : node.body)
+                        checkDataMember(member, path, seen, renderParameter);
+                    return;
+                default:
+            }
+        };
+        /** Walk `on`: every member is a function whose parameters are data. */
+        const checkActions = (node) => {
+            for (const member of membersOf(node, types)) {
+                const key = keyOf(member);
+                const type = member.type === "TSMethodSignature" ? member : memberType(member);
+                if (type?.type !== "TSFunctionType" && type?.type !== "TSMethodSignature") {
+                    context.report({ node: member, messageId: "onData", data: { key } });
+                    continue;
+                }
+                for (const parameter of type.params) {
+                    checkData(parameterType(parameter), `on.${String(key)}(${parameterName(parameter) ?? "arg"})`, new Set());
+                }
+            }
+        };
+        return {
+            Program(node) {
+                types = collectLocalTypes(node);
+            },
+            VariableDeclarator(node) {
+                if (node.id?.type !== "Identifier" || !/^[A-Z][A-Za-z0-9]*Base$/.test(node.id.name))
+                    return;
+                const fn = node.init;
+                if (fn?.type !== "ArrowFunctionExpression" && fn?.type !== "FunctionExpression")
+                    return;
+                const annotation = parameterType(fn.params[0]);
+                for (const member of membersOf(annotation, types)) {
+                    const key = keyOf(member);
+                    const type = memberType(member);
+                    if (key === "shape")
+                        continue;
+                    if (key === "state") {
+                        const stateKey = "key" in member ? member.key : undefined;
+                        context.report({
+                            node: member,
+                            messageId: "renamed",
+                            ...(stateKey?.type === "Identifier" ? { fix: (fixer) => fixer.replaceText(stateKey, "shape") } : {}),
+                        });
+                        continue;
+                    }
+                    if (key === "props")
+                        checkData(type, "props", new Set());
+                    else if (key === "on")
+                        checkActions(type);
+                    else if (key === "children" && tier === "layouts")
+                        continue;
+                    else {
+                        context.report({
+                            node: member,
+                            messageId: "member",
+                            data: { key, children: tier === "layouts" ? ", plus the router's `children`" : "" },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+/** The name of an export specifier's identifier; undefined for a string-literal name. */
+const identifierName = (node) => (node.type === "Identifier" ? node.name : undefined);
+// -- DRAWING-2 ----------------------------------------------------------------------------------
+/** Only the sibling `index.tsx` (and its specs) may reach `component.tsx`; only `X` leaves the folder. */
+export const baseImportPair = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "A pure `component.tsx` is imported only by its sibling `index.tsx`, which never re-exports `XBase`." },
+        schema: [],
+        messages: {
+            reach: "`{{source}}` reaches into another surface's pure half. Import that surface's connected export from its folder; the pure half is a private drawing surface.",
+            reexport: "`index.tsx` re-exports `{{name}}`. The folder exports only its connected `X`; the pure `XBase` stays behind it so no other tier can bypass the owner.",
+        },
+    },
+    create(context) {
+        const isOwnIndex = roleOfFile(context) === "entry";
+        const inTier = inSplitTier(context);
+        // An import reaches a pure half when the file it resolves to has the `drawing` role of its slot.
+        const reachesPure = (source) => classifyImport(context, source)?.role === "drawing";
+        const check = (node, source) => {
+            if (typeof source !== "string" || !reachesPure(source))
+                return;
+            const isSibling = /^\.\/[^/]+$/.test(source);
+            if (isSibling && isOwnIndex)
+                return;
+            if (isSibling && !inTier)
+                return;
+            context.report({ node, messageId: "reach", data: { source } });
+        };
+        return {
+            ImportDeclaration(node) {
+                check(node, node.source?.value);
+            },
+            ExportAllDeclaration(node) {
+                check(node, node.source?.value);
+            },
+            ExportNamedDeclaration(node) {
+                const source = node.source?.value;
+                if (!source)
+                    return;
+                check(node, source);
+                if (!isOwnIndex || !inTier || node.exportKind === "type")
+                    return;
+                for (const specifier of node.specifiers ?? []) {
+                    const name = identifierName(specifier.exported) ?? identifierName(specifier.local);
+                    if (specifier.exportKind !== "type" && name !== undefined && /^[A-Z][A-Za-z0-9]*Base$/.test(name)) {
+                        context.report({ node: specifier, messageId: "reexport", data: { name } });
+                    }
+                }
+            },
+        };
+    },
+});
+// -- DRAWING-3 ----------------------------------------------------------------------------------
+/** Words that name a data status or an open/closed lifecycle, never a drawn shape. */
+const DATA_STATUS = new Set([
+    "pending", "loading", "failed", "error", "errored", "empty", "forbidden", "unavailable",
+    "skeleton", "closed", "idle", "refreshing", "retrying",
+]);
+/** The name of a pure half's shape union: `XShape`, and still the retired `XState`, so a status word is caught during the rename. */
+const SHAPE_NAME = /^[A-Z][A-Za-z0-9]*(?:Shape|State)$/;
+/** A boolean member that names a status or an open/closed lifecycle: `isOpen`, `isLoading`, `isRenewing`. */
+const STATUS_FLAG = /^is[A-Z]/;
+/** A surface's `XShape` names drawn shapes only: no data status, no open/closed, no status flag. */
+export const noDataStatusShape = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "`XShape` of a pure half (a union, an interface or an inline `shape` object) names drawn shapes, never a data status, open/closed or a status flag." },
+        schema: [],
+        messages: {
+            status: "`{{name}}` lists \"{{value}}\" as a shape. Loading, forbidden, error and empty describe resource status: pass them as data to the owned status renderer. Open/closed is a boolean atom. A shape is a layout the owner approves as one drawing.",
+            flag: "`{{name}}` carries the flag `{{key}}`. A shape names a drawing, never a status or open/closed flag: a read's status goes through its DataSlot and SlotView, a pending mutation is a prop of its control, and open/closed is a boolean atom in `props`.",
+        },
+    },
+    create(context) {
+        if (!pureHalf(context))
+            return {};
+        const checkMembers = (name, members) => {
+            for (const member of members) {
+                const key = keyOf(member);
+                const type = memberType(member);
+                if ((typeof key === "string" && STATUS_FLAG.test(key)) || type?.type === "TSBooleanKeyword") {
+                    context.report({ node: member, messageId: "flag", data: { name, key: String(key) } });
+                }
+                else if (type !== undefined) {
+                    check(name, type);
+                }
+            }
+        };
+        const check = (name, node) => {
+            if (node.type === "TSTypeLiteral") {
+                checkMembers(name, node.members);
+                return;
+            }
+            const members = node.type === "TSUnionType" ? node.types : [node];
+            for (const member of members) {
+                if (member.type === "TSTypeLiteral") {
+                    checkMembers(name, member.members);
+                    continue;
+                }
+                const value = member.type === "TSLiteralType" && "value" in member.literal ? member.literal.value : undefined;
+                if (typeof value === "string" && DATA_STATUS.has(value)) {
+                    context.report({ node: member, messageId: "status", data: { name, value } });
+                }
+            }
+        };
+        return {
+            TSTypeAliasDeclaration(node) {
+                if (SHAPE_NAME.test(node.id.name))
+                    check(node.id.name, node.typeAnnotation);
+            },
+            TSInterfaceDeclaration(node) {
+                if (SHAPE_NAME.test(node.id.name))
+                    checkMembers(node.id.name, node.body.body);
+            },
+            TSPropertySignature(node) {
+                const type = node.typeAnnotation?.typeAnnotation;
+                if (keyOf(node) !== "shape" || type === undefined || type.type === "TSTypeReference")
+                    return;
+                check("shape", type);
+            },
+        };
+    },
+});
+/** The rules this law contributes to the plugin. */
+export const rules = {
+    "base-props-atom": basePropsAtom,
+    "base-import-pair": baseImportPair,
+    "no-data-status-shape": noDataStatusShape,
+};
+/** Every FE canon rule is an error; existing debt is fixed before adoption. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]));

package/dist/env-owner.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The rules that hold `env-owner.md` (HFS R49, `FE_ENV_OWNER`).
+ *
+ * TWO FACTS, ONE OWNER. The environment is read in exactly one place, `modules/config`, and what it
+ * reads has no default that stands in for a real deployment value. They are one law because they
+ * fail together: an app with nine copies of `process.env.API_URL ?? "http://localhost:3068"` had
+ * nine readers and nine silent defaults, so a production build with the variable missing talked to
+ * a developer's laptop and looked healthy.
+ *
+ * The rules cannot see whether `modules/config` throws when a variable is missing in production -
+ * that is a behaviour, and the module's own spec is where it is proven. What they hold is the
+ * shape that makes it provable: one reader, and no literal fallback next to it.
+ */
+import { type Recommended, type Rules } from "./lib/rule.js";
+/** Only `modules/config` reads the environment. */
+export declare const noEnvOutsideConfig: import("./lib/rule.js").Rule<"env", []>;
+/** A fallback never stands in for a deployment address or secret. */
+export declare const noHardcodedEndpointFallback: import("./lib/rule.js").Rule<"url" | "variable", []>;
+/** The rules this law contributes to the plugin. */
+export declare const rules: Rules;
+/** Both are exact syntactic shapes, and both are errors. */
+export declare const recommended: Recommended;