@dereekb/util 13.11.14 → 13.11.15

package/eslint/src/lib/plugin.d.ts

@@ -1,5 +1,30 @@
 import { type UtilRequireNoSideEffectsRuleDefinition } from './require-no-side-effects.rule';
 import { type UtilPreferNoSideEffectsInJsdocRuleDefinition } from './prefer-no-side-effects-in-jsdoc.rule';
+import { type UtilNoSisterReExportRuleDefinition } from './no-sister-re-export.rule';
+import { type UtilRequireSingleReturnRuleDefinition } from './require-single-return.rule';
+import { type UtilRequireReadonlyConfigParamsRuleDefinition } from './require-readonly-config-params.rule';
+import { type UtilPreferConfigObjectRuleDefinition } from './prefer-config-object.rule';
+import { type UtilPreferMaybeTypeRuleDefinition } from './prefer-maybe-type.rule';
+import { type UtilNoInlineTypeImportRuleDefinition } from './no-inline-type-import.rule';
+import { type UtilRequireDeprecatedAliasPlacementRuleDefinition } from './require-deprecated-alias-placement.rule';
+import { type UtilPreferCanonicalJsdocRuleDefinition } from './prefer-canonical-jsdoc.rule';
+import { type UtilRequireDbxUtilCompanionTagsRuleDefinition } from './require-dbx-util-companion-tags.rule';
+import { type UtilRequireDbxPipeCompanionTagsRuleDefinition } from './require-dbx-pipe-companion-tags.rule';
+import { type UtilRequireDbxFilterCompanionTagsRuleDefinition } from './require-dbx-filter-companion-tags.rule';
+import { type UtilRequireDbxWebCompanionTagsRuleDefinition } from './require-dbx-web-companion-tags.rule';
+import { type UtilRequireDbxDocsUiExampleCompanionTagsRuleDefinition } from './require-dbx-docs-ui-example-companion-tags.rule';
+import { type UtilRequireDbxModelSnapshotFieldCompanionTagsRuleDefinition } from './require-dbx-model-snapshot-field-companion-tags.rule';
+import { type UtilRequireDbxModelFirebaseIndexCompanionTagsRuleDefinition } from './require-dbx-model-firebase-index-companion-tags.rule';
+import { type UtilRequireDbxActionCompanionTagsRuleDefinition } from './require-dbx-action-companion-tags.rule';
+import { type UtilRequireDbxFormFieldCompanionTagsRuleDefinition } from './require-dbx-form-field-companion-tags.rule';
+import { type UtilRequireDbxModelCompanionTagsRuleDefinition } from './require-dbx-model-companion-tags.rule';
+import { type UtilRequireDbxAuthCompanionTagsRuleDefinition } from './require-dbx-auth-companion-tags.rule';
+import { type UtilRequireDbxRuleCompanionTagsRuleDefinition } from './require-dbx-rule-companion-tags.rule';
+import { type UtilRequireConstantNamingRuleDefinition } from './require-constant-naming.rule';
+import { type UtilRequireDefaultPrefixNamingRuleDefinition } from './require-default-prefix-naming.rule';
+import { type UtilRequireExportedJsdocExampleRuleDefinition } from './require-exported-jsdoc-example.rule';
+import { type UtilNoInlineStringEmptyObjectIntersectionRuleDefinition } from './no-inline-string-empty-object-intersection.rule';
+import { type UtilPreferSuggestedStringRuleDefinition } from './prefer-suggested-string.rule';
 /**
  * ESLint plugin interface for @dereekb/util rules.
  */
@@ -7,6 +32,32 @@ export interface UtilEslintPlugin {
     readonly rules: {
         readonly 'require-no-side-effects': UtilRequireNoSideEffectsRuleDefinition;
         readonly 'prefer-no-side-effects-in-jsdoc': UtilPreferNoSideEffectsInJsdocRuleDefinition;
+        readonly 'no-sister-re-export': UtilNoSisterReExportRuleDefinition;
+        readonly 'require-single-return': UtilRequireSingleReturnRuleDefinition;
+        readonly 'require-readonly-config-params': UtilRequireReadonlyConfigParamsRuleDefinition;
+        readonly 'prefer-config-object': UtilPreferConfigObjectRuleDefinition;
+        readonly 'prefer-config-object-hard': UtilPreferConfigObjectRuleDefinition;
+        readonly 'prefer-maybe-type': UtilPreferMaybeTypeRuleDefinition;
+        readonly 'no-inline-type-import': UtilNoInlineTypeImportRuleDefinition;
+        readonly 'require-deprecated-alias-placement': UtilRequireDeprecatedAliasPlacementRuleDefinition;
+        readonly 'prefer-canonical-jsdoc': UtilPreferCanonicalJsdocRuleDefinition;
+        readonly 'require-dbx-util-companion-tags': UtilRequireDbxUtilCompanionTagsRuleDefinition;
+        readonly 'require-dbx-pipe-companion-tags': UtilRequireDbxPipeCompanionTagsRuleDefinition;
+        readonly 'require-dbx-filter-companion-tags': UtilRequireDbxFilterCompanionTagsRuleDefinition;
+        readonly 'require-dbx-web-companion-tags': UtilRequireDbxWebCompanionTagsRuleDefinition;
+        readonly 'require-dbx-docs-ui-example-companion-tags': UtilRequireDbxDocsUiExampleCompanionTagsRuleDefinition;
+        readonly 'require-dbx-model-snapshot-field-companion-tags': UtilRequireDbxModelSnapshotFieldCompanionTagsRuleDefinition;
+        readonly 'require-dbx-model-firebase-index-companion-tags': UtilRequireDbxModelFirebaseIndexCompanionTagsRuleDefinition;
+        readonly 'require-dbx-action-companion-tags': UtilRequireDbxActionCompanionTagsRuleDefinition;
+        readonly 'require-dbx-form-field-companion-tags': UtilRequireDbxFormFieldCompanionTagsRuleDefinition;
+        readonly 'require-dbx-model-companion-tags': UtilRequireDbxModelCompanionTagsRuleDefinition;
+        readonly 'require-dbx-auth-companion-tags': UtilRequireDbxAuthCompanionTagsRuleDefinition;
+        readonly 'require-dbx-rule-companion-tags': UtilRequireDbxRuleCompanionTagsRuleDefinition;
+        readonly 'require-constant-naming': UtilRequireConstantNamingRuleDefinition;
+        readonly 'require-default-prefix-naming': UtilRequireDefaultPrefixNamingRuleDefinition;
+        readonly 'require-exported-jsdoc-example': UtilRequireExportedJsdocExampleRuleDefinition;
+        readonly 'no-inline-string-empty-object-intersection': UtilNoInlineStringEmptyObjectIntersectionRuleDefinition;
+        readonly 'prefer-suggested-string': UtilPreferSuggestedStringRuleDefinition;
     };
 }
 /**
@@ -15,4 +66,4 @@ export interface UtilEslintPlugin {
  * Register as a plugin in your flat ESLint config, then enable individual rules
  * under the chosen plugin prefix (e.g. 'dereekb-util/require-no-side-effects').
  */
-export declare const utilEslintPlugin: UtilEslintPlugin;
+export declare const UTIL_ESLINT_PLUGIN: UtilEslintPlugin;

package/eslint/src/lib/prefer-canonical-jsdoc.rule.d.ts

@@ -0,0 +1,68 @@
+import type { Maybe } from '@dereekb/util';
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the prefer-canonical-jsdoc rule. Each `checkX` flag toggles a related group of
+ * messageIds; default is `true` for all checks.
+ */
+export interface UtilPreferCanonicalJsdocRuleOptions {
+    readonly checkDescription?: boolean;
+    readonly checkParam?: boolean;
+    readonly checkReturns?: boolean;
+    readonly checkThrows?: boolean;
+    readonly checkTagOrder?: boolean;
+    readonly checkExampleFence?: boolean;
+    readonly checkTypeRestating?: boolean;
+    readonly checkSingleLine?: boolean;
+    readonly workspaceTagPrefixes?: readonly string[];
+}
+/**
+ * ESLint rule definition for prefer-canonical-jsdoc.
+ */
+export interface UtilPreferCanonicalJsdocRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: Readonly<Record<string, string>>;
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilPreferCanonicalJsdocRuleOptions[];
+        report: (descriptor: {
+            node?: AstNode;
+            loc?: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+            fix?: (fixer: AstNode) => Maybe<AstNode | AstNode[]>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing the workspace's canonical JSDoc shape. Applies only when a JSDoc block
+ * already exists on a function-like declaration; presence is `jsdoc/require-jsdoc`'s concern.
+ *
+ * The rule defends the shape established across `@dereekb/util`, `@dereekb/date`, `@dereekb/firebase`,
+ * and `@dereekb/dbx-core`:
+ *
+ * - Description: capitalized first paragraph ending with terminal punctuation, optional elaboration paragraphs
+ *   separated by exactly one blank `* ` line.
+ * - `@param name - Capitalized description.` with hyphen and surrounding spaces.
+ * - `@returns Capitalized description.` without a hyphen.
+ * - `@throws {ErrorType} Capitalized condition.` with brace-wrapped error type.
+ * - Tag order: `@param*`, `@returns`, `@throws*`, workspace tags (`@dbx*`, `@see`), `@example`, `@__NO_SIDE_EFFECTS__`.
+ * - `@example` body fenced as triple-backtick `ts` block.
+ * - No type-restating descriptions ("a string …", "an array of …").
+ * - Single-line JSDocs forbidden on functions with parameters.
+ *
+ * Heuristics are tuned to pass on the canonical examples in the existing codebase; warnings on
+ * older non-canonical JSDocs are expected and acceptable per workspace policy.
+ */
+export declare const UTIL_PREFER_CANONICAL_JSDOC_RULE: UtilPreferCanonicalJsdocRuleDefinition;
+export {};

package/eslint/src/lib/prefer-config-object.rule.d.ts

@@ -0,0 +1,61 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options accepted by the prefer-config-object rule (and the hard variant).
+ */
+export interface UtilPreferConfigObjectRuleOptions {
+    /**
+     * Maximum number of positional parameters before the rule fires. Defaults to 2 for the warn
+     * variant (`prefer-config-object`) and 4 for the hard variant (`prefer-config-object-hard`).
+     */
+    readonly maxParams?: number;
+    /**
+     * JSDoc tag that exempts a function from this rule. Defaults to `@dbxAllowMultiParams`.
+     */
+    readonly allowJsdocTag?: string;
+}
+/**
+ * ESLint rule definition for prefer-config-object.
+ */
+export interface UtilPreferConfigObjectRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: {
+            readonly tooManyParams: string;
+        };
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilPreferConfigObjectRuleOptions[];
+        report: (descriptor: {
+            node: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule recommending a single config object when a function takes more than two positional
+ * parameters (default `maxParams: 2`, i.e. fires at 3+ args). Intended to be configured at the
+ * `warn` severity. Pair with `prefer-config-object-hard` for a stricter cap.
+ *
+ * @see `dbx__note__typescript-programming` → Prefer Single Config Object
+ */
+export declare const UTIL_PREFER_CONFIG_OBJECT_RULE: UtilPreferConfigObjectRuleDefinition;
+/**
+ * Hard-stop variant of `prefer-config-object`. Fires when a function takes more than four positional
+ * parameters (default `maxParams: 4`, i.e. fires at 5+ args). Intended to be configured at the
+ * `error` severity so genuinely unwieldy signatures break the build even when the softer warn-level
+ * rule is disabled or downgraded.
+ *
+ * @see `dbx__note__typescript-programming` → Prefer Single Config Object
+ */
+export declare const UTIL_PREFER_CONFIG_OBJECT_HARD_RULE: UtilPreferConfigObjectRuleDefinition;
+export {};

package/eslint/src/lib/prefer-maybe-type.rule.d.ts

@@ -0,0 +1,72 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options accepted by the prefer-maybe-type rule.
+ */
+export interface UtilPreferMaybeTypeRuleOptions {
+    /**
+     * Type names that should be left untouched even when present in an explicit null/undefined union.
+     * Useful when a name like `Maybe`-flavored alias is already in the union and a rewrite would create
+     * `Maybe<Maybe<T>>`-style nesting.
+     */
+    readonly allowedTypeNames?: readonly string[];
+    /**
+     * When true, the rule still reports `T | null` unions but skips the auto-fix entirely and emits a
+     * message instructing the developer to import `Maybe` via a relative path. Used inside the
+     * `@dereekb/util` package itself, where the default auto-fix would insert
+     * `import type { Maybe } from '@dereekb/util';` — a circular self-import. Defaults to `false`.
+     */
+    readonly noAutoImport?: boolean;
+}
+/**
+ * ESLint rule definition for prefer-maybe-type.
+ */
+export interface UtilPreferMaybeTypeRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: {
+            readonly preferMaybe: string;
+            readonly preferMaybeNoAutoImport: string;
+        };
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilPreferMaybeTypeRuleOptions[];
+        report: (descriptor: {
+            node: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+            fix?: (fixer: AstNode) => AstNode | AstNode[];
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule that flags explicit `T | null` and `T | null | undefined` unions (including the
+ * combination of an optional modifier with `| null`, e.g. `foo?: T | null`) and recommends using
+ * `Maybe<T>` from `@dereekb/util` instead. The rule targets only unions that explicitly include
+ * `null` — `T | undefined` alone is left untouched because `x?: T` and `T | undefined` are the
+ * common, intentional shapes for "value may be absent" and have no canonical `Maybe<T>` equivalent
+ * to push toward when `null` isn't involved.
+ *
+ * Auto-fix rewrites the union as `Maybe<...>` and (once per file) inserts
+ * `import type { Maybe } from '@dereekb/util';` near the top of the file. The workspace's
+ * `import/no-duplicates` rule (configured with `prefer-inline: true`) consolidates the new
+ * import with any existing `@dereekb/util` import on subsequent fix passes.
+ *
+ * When the `noAutoImport` option is `true`, the rule still reports the union but skips the auto-fix
+ * and emits a message instructing the developer to import `Maybe` via a relative path. This is the
+ * configuration used inside the `@dereekb/util` package itself, where the default auto-fix would
+ * insert a circular self-import.
+ *
+ * @see `dbx__note__typescript-programming` → Maybe<T> Usage
+ */
+export declare const UTIL_PREFER_MAYBE_TYPE_RULE: UtilPreferMaybeTypeRuleDefinition;
+export {};

package/eslint/src/lib/prefer-no-side-effects-in-jsdoc.rule.d.ts

@@ -46,5 +46,5 @@ export interface UtilPreferNoSideEffectsInJsdocRuleDefinition {
  * (and treats line comments between overloads — but not directly above the impl —
  * as ordinary orphans to migrate).
  */
-export declare const utilPreferNoSideEffectsInJsdocRule: UtilPreferNoSideEffectsInJsdocRuleDefinition;
+export declare const UTIL_PREFER_NO_SIDE_EFFECTS_IN_JSDOC_RULE: UtilPreferNoSideEffectsInJsdocRuleDefinition;
 export {};

package/eslint/src/lib/prefer-suggested-string.rule.d.ts

@@ -0,0 +1,51 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * ESLint rule definition for prefer-suggested-string.
+ */
+export interface UtilPreferSuggestedStringRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: {
+            readonly preferSuggestedString: string;
+        };
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        report: (descriptor: {
+            node: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: {
+            getText: (node: AstNode) => string;
+        };
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule that warns on union types of the shape `'a' | 'b' | string` — a literal-string
+ * union members alongside a bare `string` member.
+ *
+ * The TypeScript compiler collapses such a union to `string`, erasing IDE autocomplete for the
+ * literal members. Two outcomes are sane:
+ *
+ * 1. If autocomplete-preserving behavior is actually wanted, switch to `SuggestedString<T>` from
+ *    `@dereekb/util` (the named alias for the `'a' | 'b' | (string & {})` workaround).
+ * 2. If any string is fine and literals were just documentation, drop the literal members and
+ *    keep plain `string`.
+ *
+ * The rule is non-fixable: the right action depends on intent (#1 vs #2), and #1 also requires
+ * adding an `import { type SuggestedString }` statement whose insertion point varies by file. The
+ * warning message names both options so the developer can make the call.
+ *
+ * Only fires when the union contains BOTH a `TSStringKeyword` AND at least one literal-string
+ * contributor. Unions like `string | number`, `'a' | 'b'`, or `string` alone are silent.
+ */
+export declare const UTIL_PREFER_SUGGESTED_STRING_RULE: UtilPreferSuggestedStringRuleDefinition;
+export {};

package/eslint/src/lib/require-constant-naming.rule.d.ts

@@ -0,0 +1,63 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options accepted by the require-constant-naming rule.
+ */
+export interface UtilRequireConstantNamingRuleOptions {
+    /**
+     * JSDoc tag that exempts a matching const from the rule.
+     * Defaults to `@dbxAllowConstantName`.
+     */
+    readonly exemptJsdocTag?: string;
+}
+/**
+ * ESLint rule definition for require-constant-naming.
+ */
+export interface UtilRequireConstantNamingRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: undefined;
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: {
+            readonly functionConstantShouldBeCamelCase: string;
+            readonly valueConstantShouldBeUpperSnakeCase: string;
+        };
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilRequireConstantNamingRuleOptions[];
+        report: (descriptor: {
+            node: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule that enforces the dbx-components Constant Naming convention on exported top-level
+ * `const` declarations:
+ *
+ * - Function-typed constants (arrow/function expression initializers, or `: TSFunctionType`
+ *   annotations) may be camelCase (the usual callable casing) or UPPER_SNAKE_CASE (when the binding
+ *   is treated as a constant-shaped function reference, e.g. a default factory or registered hook).
+ * - Plain-value constants (string/number/boolean/array/object/`new`/template-literal initializers)
+ *   must be UPPER_SNAKE_CASE. PascalCase is also accepted for class- and enum-like singletons.
+ *
+ * The rule deliberately skips ambiguous initializers (CallExpressions, identifier aliases, member
+ * accesses) because we can't tell without type information whether the binding will end up callable.
+ * Use the exempt JSDoc tag (default `@dbxAllowConstantName`) to silence the rule on a specific
+ * declaration when the heuristics get it wrong.
+ *
+ * Not auto-fixable: renaming an exported binding has cross-file impact that an autofix can't safely
+ * propagate.
+ *
+ * @see `dbx__note__typescript-programming` → Constant Naming.
+ */
+export declare const UTIL_REQUIRE_CONSTANT_NAMING_RULE: UtilRequireConstantNamingRuleDefinition;
+export {};

package/eslint/src/lib/require-dbx-action-companion-tags.rule.d.ts

@@ -0,0 +1,46 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-action-companion-tags rule.
+ */
+export interface UtilRequireDbxActionCompanionTagsRuleOptions {
+    readonly allowedRoles?: readonly string[];
+    readonly allowedStates?: readonly string[];
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-action-companion-tags.
+ */
+export interface UtilRequireDbxActionCompanionTagsRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: Readonly<Record<string, string>>;
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilRequireDbxActionCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            loc?: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing `@dbxAction` companion tags. Mirrors the scanner
+ * schema at `packages/dbx-components-mcp/src/scan/actions-extract.ts`. Class
+ * declarations carry the `@dbxAction` marker; enum declarations carry the
+ * `@dbxActionStateEnum` marker, and `@dbxActionStateTransitionsFrom/To` are
+ * valid on enum-member JSDocs.
+ */
+export declare const UTIL_REQUIRE_DBX_ACTION_COMPANION_TAGS_RULE: UtilRequireDbxActionCompanionTagsRuleDefinition;
+export {};

package/eslint/src/lib/require-dbx-auth-companion-tags.rule.d.ts

@@ -0,0 +1,45 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-auth-companion-tags rule.
+ */
+export interface UtilRequireDbxAuthCompanionTagsRuleOptions {
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-auth-companion-tags.
+ */
+export interface UtilRequireDbxAuthCompanionTagsRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: Readonly<Record<string, string>>;
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilRequireDbxAuthCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            loc?: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing the three `@dbxAuth*` marker families. Mirrors the
+ * scanner schema at `packages/dbx-components-mcp/src/scan/auth-extract.ts`.
+ *
+ * - `@dbxAuthClaimsApp <slug>` on an interface / type alias.
+ * - `@dbxAuthClaim` (bare) on a `PropertySignature` inside an interface.
+ * - `@dbxAuthClaimsService <slug>` on an exported `VariableDeclaration`.
+ */
+export declare const UTIL_REQUIRE_DBX_AUTH_COMPANION_TAGS_RULE: UtilRequireDbxAuthCompanionTagsRuleDefinition;
+export {};

package/eslint/src/lib/require-dbx-docs-ui-example-companion-tags.rule.d.ts

@@ -0,0 +1,42 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-docs-ui-example-companion-tags rule.
+ */
+export interface UtilRequireDbxDocsUiExampleCompanionTagsRuleOptions {
+    readonly allowedCategories?: readonly string[];
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-docs-ui-example-companion-tags.
+ */
+export interface UtilRequireDbxDocsUiExampleCompanionTagsRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: Readonly<Record<string, string>>;
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilRequireDbxDocsUiExampleCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            loc?: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing `@dbxDocsUiExample` companion tags. Mirrors the
+ * scanner schema at `packages/dbx-components-mcp/src/scan/dbx-docs-ui-examples-extract.ts`.
+ */
+export declare const UTIL_REQUIRE_DBX_DOCS_UI_EXAMPLE_COMPANION_TAGS_RULE: UtilRequireDbxDocsUiExampleCompanionTagsRuleDefinition;
+export {};

package/eslint/src/lib/require-dbx-filter-companion-tags.rule.d.ts

@@ -0,0 +1,43 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-filter-companion-tags rule.
+ */
+export interface UtilRequireDbxFilterCompanionTagsRuleOptions {
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-filter-companion-tags.
+ */
+export interface UtilRequireDbxFilterCompanionTagsRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: Readonly<Record<string, string>>;
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilRequireDbxFilterCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            loc?: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing `@dbxFilter` companion tags. Mirrors the scanner
+ * schema at `packages/dbx-components-mcp/src/scan/filters-extract.ts`.
+ * Applies to classes (filter directives) and exported interfaces (filter
+ * patterns); the scanner reads both as filter entries.
+ */
+export declare const UTIL_REQUIRE_DBX_FILTER_COMPANION_TAGS_RULE: UtilRequireDbxFilterCompanionTagsRuleDefinition;
+export {};

package/eslint/src/lib/require-dbx-form-field-companion-tags.rule.d.ts

@@ -0,0 +1,46 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-form-field-companion-tags rule.
+ */
+export interface UtilRequireDbxFormFieldCompanionTagsRuleOptions {
+    readonly allowedTiers?: readonly string[];
+    readonly allowedWrapperPatterns?: readonly string[];
+    readonly allowedSuffixes?: readonly string[];
+    readonly allowedArrayOutputs?: readonly string[];
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-form-field-companion-tags.
+ */
+export interface UtilRequireDbxFormFieldCompanionTagsRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: Readonly<Record<string, string>>;
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilRequireDbxFormFieldCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            loc?: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing `@dbxFormField` companion tags. Mirrors the scanner
+ * schema at `packages/dbx-components-mcp/src/scan/forge-fields-extract.ts`,
+ * including the tier-conditional required-tag matrix.
+ */
+export declare const UTIL_REQUIRE_DBX_FORM_FIELD_COMPANION_TAGS_RULE: UtilRequireDbxFormFieldCompanionTagsRuleDefinition;
+export {};

package/eslint/src/lib/require-dbx-model-companion-tags.rule.d.ts

@@ -0,0 +1,46 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-model-companion-tags rule.
+ */
+export interface UtilRequireDbxModelCompanionTagsRuleOptions {
+    readonly allowedEncodings?: readonly string[];
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-model-companion-tags.
+ */
+export interface UtilRequireDbxModelCompanionTagsRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: Readonly<Record<string, string>>;
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilRequireDbxModelCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            loc?: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing `@dbxModel` / `@dbxModelSubObject` / `@dbxModelOrganizationalGroupRoot`
+ * companion tags. Mirrors the scanner schema at
+ * `packages/dbx-components-mcp/src/scan/extract-models/find-interfaces.ts`.
+ *
+ * Does NOT enforce a Slug / Category / Tags shape because the scanner does
+ * not consume those for this family.
+ */
+export declare const UTIL_REQUIRE_DBX_MODEL_COMPANION_TAGS_RULE: UtilRequireDbxModelCompanionTagsRuleDefinition;
+export {};