@dereekb/util 13.11.14 → 13.11.15

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

@@ -0,0 +1,44 @@
+import type { Maybe } from '@dereekb/util';
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-model-firebase-index-companion-tags rule.
+ */
+export interface UtilRequireDbxModelFirebaseIndexCompanionTagsRuleOptions {
+    readonly allowedScopes?: readonly string[];
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-model-firebase-index-companion-tags.
+ */
+export interface UtilRequireDbxModelFirebaseIndexCompanionTagsRuleDefinition {
+    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: UtilRequireDbxModelFirebaseIndexCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            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 `@dbxModelFirebaseIndex` companion tags. Mirrors the
+ * scanner schema at `packages/dbx-components-mcp/src/scan/model-firebase-index-extract.ts`.
+ */
+export declare const UTIL_REQUIRE_DBX_MODEL_FIREBASE_INDEX_COMPANION_TAGS_RULE: UtilRequireDbxModelFirebaseIndexCompanionTagsRuleDefinition;
+export {};

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

@@ -0,0 +1,44 @@
+import type { Maybe } from '@dereekb/util';
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-model-snapshot-field-companion-tags rule.
+ */
+export interface UtilRequireDbxModelSnapshotFieldCompanionTagsRuleOptions {
+    readonly allowedKinds?: readonly string[];
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-model-snapshot-field-companion-tags.
+ */
+export interface UtilRequireDbxModelSnapshotFieldCompanionTagsRuleDefinition {
+    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: UtilRequireDbxModelSnapshotFieldCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            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 `@dbxModelSnapshotField` companion tags. Mirrors the
+ * scanner schema at `packages/dbx-components-mcp/src/scan/model-snapshot-fields-extract.ts`.
+ */
+export declare const UTIL_REQUIRE_DBX_MODEL_SNAPSHOT_FIELD_COMPANION_TAGS_RULE: UtilRequireDbxModelSnapshotFieldCompanionTagsRuleDefinition;
+export {};

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

@@ -0,0 +1,43 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-pipe-companion-tags rule.
+ */
+export interface UtilRequireDbxPipeCompanionTagsRuleOptions {
+    readonly allowedCategories?: readonly string[];
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-pipe-companion-tags.
+ */
+export interface UtilRequireDbxPipeCompanionTagsRuleDefinition {
+    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: UtilRequireDbxPipeCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            loc?: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing `@dbxPipe` companion tags. Mirrors the scanner schema
+ * at `packages/dbx-components-mcp/src/scan/pipes-extract.ts` so violations
+ * surface at lint time instead of at manifest-regeneration time.
+ */
+export declare const UTIL_REQUIRE_DBX_PIPE_COMPANION_TAGS_RULE: UtilRequireDbxPipeCompanionTagsRuleDefinition;
+export {};

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

@@ -0,0 +1,44 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-rule-companion-tags rule.
+ */
+export interface UtilRequireDbxRuleCompanionTagsRuleOptions {
+    readonly allowedSeverities?: readonly string[];
+    readonly allowedSeeAlsoKinds?: readonly string[];
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-rule-companion-tags.
+ */
+export interface UtilRequireDbxRuleCompanionTagsRuleDefinition {
+    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: UtilRequireDbxRuleCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            loc?: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing `@dbxRule` companion tags on enum members in
+ * `codes.ts` files. Mirrors the extractor at
+ * `packages/dbx-components-mcp/scripts/extract-rule-catalog.mjs`.
+ */
+export declare const UTIL_REQUIRE_DBX_RULE_COMPANION_TAGS_RULE: UtilRequireDbxRuleCompanionTagsRuleDefinition;
+export {};

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

@@ -0,0 +1,74 @@
+import type { Maybe } from '@dereekb/util';
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-util-companion-tags rule.
+ */
+export interface UtilRequireDbxUtilCompanionTagsRuleOptions {
+    /**
+     * When provided, `@dbxUtilCategory` values must be in this list. When omitted, any kebab-case
+     * slug is accepted.
+     */
+    readonly allowedCategories?: readonly string[];
+    /**
+     * Override the set of values accepted for `@dbxUtilKind`. Defaults to `['function', 'class', 'const', 'factory']`.
+     */
+    readonly allowedKinds?: readonly string[];
+    /**
+     * Override the companion-tag whitelist (without the `dbxUtil` prefix). Defaults to `['Category', 'Kind', 'Tags', 'Related']`.
+     */
+    readonly knownCompanions?: readonly string[];
+    /**
+     * When true (default), only the bare `@dbxUtil` tag triggers the rule. When false, any
+     * `@dbxUtil*` tag triggers it (useful for partial-block detection).
+     */
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-util-companion-tags.
+ */
+export interface UtilRequireDbxUtilCompanionTagsRuleDefinition {
+    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: UtilRequireDbxUtilCompanionTagsRuleOptions[];
+        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 that exports tagged `@dbxUtil` carry the registry-required companion tags
+ * with valid value formats. Mirrors the scanner schema at
+ * `packages/dbx-components-mcp/src/scan/utils-extract.ts` so violations surface at lint time
+ * instead of at manifest-regeneration time.
+ *
+ * Checks:
+ *
+ * - `@dbxUtilCategory` is present (required) with a kebab-case slug value.
+ * - `@dbxUtilKind` (optional) has a value from the configured enum.
+ * - `@dbxUtilRelated` (optional) items are all kebab-case slugs.
+ * - `@dbxUtilTags` (optional) tokens are all lowercase.
+ * - Unknown `@dbxUtil*` tags (typos like `@dbxUtilCateogry`) are flagged.
+ * - Companion tags appear at most once each.
+ *
+ * Only the `@dbxUtilTags` lowercase fix is auto-applied. Category, kind, and related-slug
+ * violations are report-only — they require human / agent judgment on the correct value.
+ */
+export declare const UTIL_REQUIRE_DBX_UTIL_COMPANION_TAGS_RULE: UtilRequireDbxUtilCompanionTagsRuleDefinition;
+export {};

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

@@ -0,0 +1,43 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options for the require-dbx-web-companion-tags rule.
+ */
+export interface UtilRequireDbxWebCompanionTagsRuleOptions {
+    readonly allowedCategories?: readonly string[];
+    readonly allowedKinds?: readonly string[];
+    readonly knownCompanions?: readonly string[];
+    readonly requireBareMarker?: boolean;
+}
+/**
+ * ESLint rule definition for require-dbx-web-companion-tags.
+ */
+export interface UtilRequireDbxWebCompanionTagsRuleDefinition {
+    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: UtilRequireDbxWebCompanionTagsRuleOptions[];
+        report: (descriptor: {
+            loc?: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing `@dbxWebComponent` companion tags. Mirrors the scanner
+ * schema at `packages/dbx-components-mcp/src/scan/ui-components-extract.ts`.
+ */
+export declare const UTIL_REQUIRE_DBX_WEB_COMPANION_TAGS_RULE: UtilRequireDbxWebCompanionTagsRuleDefinition;
+export {};

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

@@ -0,0 +1,60 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options accepted by the require-default-prefix-naming rule.
+ */
+export interface UtilRequireDefaultPrefixNamingRuleOptions {
+    /**
+     * JSDoc tag that exempts a matching const from the rule.
+     * Defaults to `@dbxAllowDefaultPrefix`.
+     */
+    readonly exemptJsdocTag?: string;
+}
+/**
+ * ESLint rule definition for require-default-prefix-naming.
+ */
+export interface UtilRequireDefaultPrefixNamingRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: undefined;
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: {
+            readonly defaultShouldBePrefix: string;
+        };
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilRequireDefaultPrefixNamingRuleOptions[];
+        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 naming convention: when a SCREAMING_CASE binding
+ * contains the segment `DEFAULT` (e.g. `FOO_DEFAULT_BAR` or `FOO_BAR_DEFAULT`), the `DEFAULT_`
+ * segment must appear as the leading prefix instead (`DEFAULT_FOO_BAR`).
+ *
+ * Rationale: keeping `DEFAULT_` as a leading prefix makes default-providing constants trivially
+ * groupable in IDE symbol lists and import bars, and matches the rest of the codebase's
+ * `DEFAULT_X_Y_Z` pattern.
+ *
+ * Applies to every `VariableDeclarator` whose binding is UPPER_SNAKE_CASE. PascalCase, camelCase,
+ * underscore-prefixed (internal), and mixed names are ignored.
+ *
+ * Not auto-fixable: renaming a binding has cross-file impact that an autofix can't safely
+ * propagate. Use the exempt JSDoc tag (default `@dbxAllowDefaultPrefix`) to silence the rule on a
+ * specific declaration when the heuristics get it wrong.
+ *
+ * @see `dbx__note__typescript-programming` → Constant Naming.
+ */
+export declare const UTIL_REQUIRE_DEFAULT_PREFIX_NAMING_RULE: UtilRequireDefaultPrefixNamingRuleDefinition;
+export {};

package/eslint/src/lib/require-deprecated-alias-placement.rule.d.ts

@@ -0,0 +1,75 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * ESLint fixer interface (loose-typed because the rule keeps its own no-deps `AstNode = any`).
+ */
+interface RuleFixer {
+    readonly removeRange: (range: readonly [number, number]) => unknown;
+    readonly replaceTextRange: (range: readonly [number, number], text: string) => unknown;
+    readonly insertTextAfterRange: (range: readonly [number, number], text: string) => unknown;
+}
+/**
+ * ESLint rule definition for require-deprecated-alias-placement.
+ */
+export interface UtilRequireDeprecatedAliasPlacementRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: {
+            readonly missingCompatMarker: string;
+            readonly deprecatedAliasNotAtBottom: string;
+            readonly nonDeprecatedAfterMarker: string;
+        };
+        readonly schema: readonly object[];
+    };
+    create(context: RuleContext): Record<string, (node: AstNode) => void>;
+}
+/**
+ * Fix function signature used throughout the rule. Returned by helper builders and consumed by
+ * `context.report({ fix })`.
+ */
+type FixFn = (fixer: RuleFixer) => unknown;
+/**
+ * Narrow shape of the ESLint rule context the rule actually uses.
+ */
+interface RuleContext {
+    readonly report: (descriptor: {
+        node: AstNode;
+        messageId: string;
+        fix?: FixFn;
+    }) => void;
+    readonly sourceCode: AstNode;
+}
+/**
+ * ESLint rule requiring that exports carrying a `@deprecated` JSDoc tag live at the bottom of the
+ * file under a `// COMPAT: Deprecated aliases` line comment, and that no non-deprecated exports
+ * follow the marker. The rule mirrors the workspace's "Deprecated Alias Placement" convention so
+ * that deprecated aliases stay segregated from current code and are easy to spot for removal.
+ *
+ * The rule reports at most one violation per concern (missing marker, alias above marker,
+ * non-deprecated below marker) to keep editor noise manageable; once the first violation in a
+ * category is fixed, re-linting will surface the next one.
+ *
+ * Autofix coverage:
+ *   - `missingCompatMarker` — inserts `// COMPAT: Deprecated aliases` and consolidates all
+ *     deprecated blocks at the bottom of the file. When the deprecated tail is already at the
+ *     bottom of the file, only the marker line is inserted (no statements are moved). When
+ *     deprecated exports are interleaved with non-deprecated ones, the autofix removes each
+ *     deprecated block from its current location and re-emits them in source order at the bottom
+ *     of the file under the marker.
+ *   - `deprecatedAliasNotAtBottom` — moves the misplaced deprecated block from above the marker to
+ *     just after the marker. One block per pass; ESLint's autofix loop converges across multiple
+ *     violations.
+ *   - `nonDeprecatedAfterMarker` — moves the misplaced non-deprecated block from below the marker
+ *     to just before the marker. One block per pass.
+ *
+ * @see `dbx__note__typescript-programming` → Deprecated Alias Placement
+ */
+export declare const UTIL_REQUIRE_DEPRECATED_ALIAS_PLACEMENT_RULE: UtilRequireDeprecatedAliasPlacementRuleDefinition;
+export {};

package/eslint/src/lib/require-exported-jsdoc-example.rule.d.ts

@@ -0,0 +1,61 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options accepted by the require-exported-jsdoc-example rule.
+ */
+export interface UtilRequireExportedJsdocExampleRuleOptions {
+    /**
+     * JSDoc tag that opts a function out of the rule. Defaults to `@dbxAllowSkipExample`.
+     */
+    readonly exemptJsdocTag?: string;
+    /**
+     * When true (the default), zero-parameter functions are skipped because their behavior is
+     * usually clear from the description alone.
+     */
+    readonly exemptNoArguments?: boolean;
+}
+/**
+ * ESLint rule definition for require-exported-jsdoc-example.
+ */
+export interface UtilRequireExportedJsdocExampleRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: undefined;
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: {
+            readonly missingExample: string;
+        };
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilRequireExportedJsdocExampleRuleOptions[];
+        report: (descriptor: {
+            node: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+        sourceCode: AstNode;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule that requires exported `function` declarations whose JSDoc is already present to
+ * also include at least one `@example` tag.
+ *
+ * Differences from `jsdoc/require-example`:
+ * - Fires only on **exported** FunctionDeclarations (top-level `export function …` or
+ *   `export default function …`). Internal helpers stay quiet.
+ * - Fires only when the function actually has a leading JSDoc block — undocumented functions are
+ *   handled by `jsdoc/require-jsdoc`.
+ * - Honors the `@dbxAllowSkipExample` JSDoc tag for per-declaration opt-out.
+ *
+ * Not auto-fixable: there's no way to synthesize a useful `@example` block automatically.
+ *
+ * @see `dbx__note__typescript-jsdocs` → "Function JSDocs Must Include Examples".
+ */
+export declare const UTIL_REQUIRE_EXPORTED_JSDOC_EXAMPLE_RULE: UtilRequireExportedJsdocExampleRuleDefinition;
+export {};

package/eslint/src/lib/require-no-side-effects.rule.d.ts

@@ -63,5 +63,5 @@ export interface UtilRequireNoSideEffectsRuleDefinition {
  * declaration (other than the required impl-leading line comment on overloaded functions), and
  * when no JSDoc is present, creates a minimal one carrying both tags.
  */
-export declare const utilRequireNoSideEffectsRule: UtilRequireNoSideEffectsRuleDefinition;
+export declare const UTIL_REQUIRE_NO_SIDE_EFFECTS_RULE: UtilRequireNoSideEffectsRuleDefinition;
 export {};

package/eslint/src/lib/require-readonly-config-params.rule.d.ts

@@ -0,0 +1,57 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * Options accepted by the require-readonly-config-params rule.
+ */
+export interface UtilRequireReadonlyConfigParamsRuleOptions {
+    /**
+     * Additional name suffixes to treat as config-shaped (joined with the defaults `Config`, `Params`).
+     */
+    readonly additionalSuffixes?: readonly string[];
+    /**
+     * JSDoc tag that exempts a matching interface from the readonly requirement.
+     * Defaults to `@dbxMutable`.
+     */
+    readonly exemptJsdocTag?: string;
+}
+/**
+ * ESLint rule definition for require-readonly-config-params.
+ */
+export interface UtilRequireReadonlyConfigParamsRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: {
+            readonly missingReadonly: string;
+        };
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: UtilRequireReadonlyConfigParamsRuleOptions[];
+        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 requiring `readonly` on every property of `*Config` / `*Params` interfaces so that Config
+ * and Params shapes stay structurally immutable at the type level. Properties that are missing the
+ * modifier are flagged and the rule auto-fixes them by inserting `readonly` before the property name.
+ *
+ * Interfaces tagged with the configured exempt JSDoc (default `@dbxMutable`) are skipped — used for
+ * Firestore model data interfaces that legitimately need mutable hydration fields.
+ *
+ * @see `dbx__note__typescript-programming` → Readonly Interface Properties
+ */
+export declare const UTIL_REQUIRE_READONLY_CONFIG_PARAMS_RULE: UtilRequireReadonlyConfigParamsRuleDefinition;
+export {};

package/eslint/src/lib/require-single-return.rule.d.ts

@@ -0,0 +1,42 @@
+interface AstNode {
+    readonly type: string;
+    [key: string]: any;
+}
+/**
+ * ESLint rule definition for require-single-return.
+ */
+export interface UtilRequireSingleReturnRuleDefinition {
+    readonly meta: {
+        readonly type: 'suggestion';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: {
+            readonly multipleReturns: string;
+        };
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        report: (descriptor: {
+            node: AstNode;
+            messageId: string;
+            data?: Record<string, string>;
+        }) => void;
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule enforcing the workspace convention of a single `return` statement per function. Functions
+ * with multiple early returns should be refactored to assign their result to a local variable and return
+ * it once. Nested function-likes are analyzed independently — only returns inside the current function
+ * scope (and the blocks that share it) count toward its tally.
+ *
+ * Simple early-exit guard clauses are exempt: a `ReturnStatement` that is the consequent — or the last
+ * statement of the consequent `BlockStatement` — of an `IfStatement` with no `else` does not count
+ * toward the tally. This permits the standard guard-clause idiom while still flagging if/else, switch,
+ * try/catch, and returns mixed into main logic.
+ *
+ * @see `dbx__note__typescript-programming` → Single Return Per Function
+ */
+export declare const UTIL_REQUIRE_SINGLE_RETURN_RULE: UtilRequireSingleReturnRuleDefinition;
+export {};