@ngcompass/rules 0.1.1-beta

package/dist/index.d.ts

@@ -0,0 +1,634 @@
+import * as _ngcompass_engine from '@ngcompass/engine';
+import { RuleHandler } from '@ngcompass/engine';
+export { RuleContextFactory, RuleHandler } from '@ngcompass/engine';
+import { AnyAngularClassNode, CallExpression, AngularClassNode, TemplateExpressionNode, TemplateAnalysis, TemplateAttributeNode } from '@ngcompass/ast';
+import { RuleMetadata, PluginManifest, RuleRegistryEntry, RuleListEntry, RuleContext, RuleResult, ResolvedRulesMap, ResolvedRule, NormalizedAnalyzerConfig, Result, RuleResolutionResult, PresetReference, PresetConfig, RuleConfig, RuleConfigFull, RulesConfig, BuiltinPreset } from '@ngcompass/common';
+import * as typescript from 'typescript';
+
+declare const componentNoManualDetectChangesRule: _ngcompass_engine.RuleHandler<AnyAngularClassNode>;
+
+declare const signalNoSideEffectsInComputedRule: _ngcompass_engine.RuleHandler<CallExpression>;
+
+declare const signalEffectDestroyScopedRule: _ngcompass_engine.RuleHandler<AnyAngularClassNode>;
+
+declare const rxjsNoNestedSubscribeRule: _ngcompass_engine.RuleHandler<CallExpression>;
+
+declare const preferOnPushRule: _ngcompass_engine.RuleHandler<AngularClassNode>;
+
+declare const templateNoCallExpressionRule: _ngcompass_engine.RuleHandler<TemplateExpressionNode>;
+
+declare const templateTrackByRequiredRule: _ngcompass_engine.RuleHandler<TemplateAnalysis>;
+
+declare const templateNoObjectLiteralBindingRule: _ngcompass_engine.RuleHandler<TemplateExpressionNode>;
+
+declare const templateNoArrayLiteralBindingRule: _ngcompass_engine.RuleHandler<TemplateExpressionNode>;
+
+declare const noBypassSanitizationRule: _ngcompass_engine.RuleHandler<CallExpression>;
+
+declare const templateNoUnsafeBindingsRule: _ngcompass_engine.RuleHandler<TemplateAttributeNode>;
+
+declare const noDocumentAccessRule: _ngcompass_engine.RuleHandler<AnyAngularClassNode>;
+
+declare const preferAfterRenderOverAfterViewInitRule: _ngcompass_engine.RuleHandler<AnyAngularClassNode>;
+
+declare const rxjsNoSubscribeInComponentRule: _ngcompass_engine.RuleHandler<CallExpression>;
+
+declare function hasManualTeardownInNgOnDestroy(fileContent: string): boolean;
+declare const rxjsRequireTakeUntilDestroyedRule: _ngcompass_engine.RuleHandler<CallExpression>;
+
+declare const rxjsAvoidSubjectRule: _ngcompass_engine.RuleHandler<AnyAngularClassNode>;
+
+declare const rxjsPreferToSignalRule: _ngcompass_engine.RuleHandler<AnyAngularClassNode>;
+
+declare const toSignalRequireInitialValueRule: _ngcompass_engine.RuleHandler<CallExpression>;
+
+declare const signalPreferComputedRule: _ngcompass_engine.RuleHandler<CallExpression>;
+
+declare const signalAvoidUntrackedRule: _ngcompass_engine.RuleHandler<CallExpression>;
+
+declare const preferInjectRule: _ngcompass_engine.RuleHandler<AnyAngularClassNode>;
+
+declare const signalPreferInputSignalRule: _ngcompass_engine.RuleHandler<AnyAngularClassNode>;
+
+declare const signalPreferOutputFunctionRule: _ngcompass_engine.RuleHandler<AnyAngularClassNode>;
+
+declare const signalPreferModelRule: _ngcompass_engine.RuleHandler<AnyAngularClassNode>;
+
+declare const templatePreferControlFlowRule: _ngcompass_engine.RuleHandler<TemplateAttributeNode>;
+
+declare const templateNoAsyncPipeDuplicationRule: _ngcompass_engine.RuleHandler<TemplateExpressionNode>;
+
+declare const specNoFocusedTestRule: _ngcompass_engine.RuleHandler<CallExpression>;
+
+/**
+ * RuleRegistry — Plugin Boundary
+ *
+ * Replaces the mutable bare Map in adapter.ts with a class that:
+ *  - Throws on duplicate registration (prevents silent stomping)
+ *  - Exposes a controlled surface for plugin authors
+ *  - Provides a global singleton for CLI / built-in usage
+ *  - Provides a reset helper for isolated test runs
+ *
+ * Plugin authors export an array of RulePlugin objects from their package.
+ * The plugin-loader reads the config `plugins` array and calls registry.register()
+ * for each plugin — no core files need to be modified.
+ *
+ * Example plugin package:
+ * ```ts
+ * // my-org-rules/src/index.ts
+ * import type { RulePlugin } from '@ngcompass/rules';
+ * import { createComponentRule } from '@ngcompass/engine';
+ *
+ * const noBareSelectorRule: RulePlugin = {
+ *   name: 'my-org/no-bare-selectors',
+ *   handler: createComponentRule('my-org/no-bare-selectors', (node, ctx) => { ... }),
+ *   meta: { category: 'style', dependencyType: 'component' },
+ * };
+ *
+ * export default [noBareSelectorRule];
+ * ```
+ *
+ * ngcompass.config.ts:
+ * ```ts
+ * export default {
+ *   plugins: ['my-org-rules'],
+ *   rules: { 'my-org/no-bare-selectors': 'high' },
+ * };
+ * ```
+ */
+
+/**
+ * A plugin descriptor — the unit external rule authors export.
+ */
+interface RulePlugin {
+    /** Globally unique rule name. Use namespacing: 'my-org/rule-name' */
+    readonly name: string;
+    /** The rule handler (created via createComponentRule, createDecoratedPropertyRule, etc.) */
+    readonly handler: RuleHandler<unknown>;
+    /** Optional metadata overrides (category, description, dependencyType, etc.) */
+    readonly meta?: Partial<RuleMetadata>;
+    /** Optional manifest (RFC §7.6) */
+    readonly manifest?: PluginManifest;
+}
+/**
+ * Options controlling registration behaviour.
+ */
+interface RegisterOptions {
+    /**
+     * Allow overwriting an existing rule with the same name.
+     * Default: false — throws on duplicate to prevent silent errors.
+     */
+    allowOverride?: boolean;
+}
+/**
+ * Central registry for rule handlers.
+ *
+ * Responsibilities:
+ *  - Store handler instances keyed by rule name
+ *  - Prevent accidental duplicate registration
+ *  - Expose read-only views for the engine and adapter
+ */
+declare class RuleRegistry {
+    private readonly _handlers;
+    private readonly _meta;
+    /**
+     * Registers a rule plugin.
+     *
+     * @throws {Error} if the rule name is already registered and allowOverride is false
+     */
+    register(plugin: RulePlugin, opts?: RegisterOptions): void;
+    /**
+     * Returns the handler for a rule name, or undefined if not registered.
+     */
+    get(name: string): RuleHandler<unknown> | undefined;
+    /**
+     * Returns true if a rule with this name is registered.
+     */
+    has(name: string): boolean;
+    /**
+     * Returns all registered rule names.
+     */
+    getRuleNames(): ReadonlyArray<string>;
+    /**
+     * Returns the full handler map (read-only view).
+     * Used by the engine adapter for batched execution.
+     */
+    getAll(): ReadonlyMap<string, RuleHandler<unknown>>;
+    /**
+     * Returns metadata overrides for a rule name, if any.
+     */
+    getMeta(name: string): Partial<RuleMetadata> | undefined;
+    /**
+     * Returns resolved RuleMetadata for a rule name.
+     * Fills in defaults for fields not specified in the plugin's meta.
+     */
+    getMetadata(name: string): RuleMetadata | undefined;
+    /**
+     * Returns a full RuleRegistryEntry (metadata + default config).
+     * Used for backward compatibility with the legacy registry API.
+     */
+    getRegistryEntry(name: string): RuleRegistryEntry | undefined;
+    /**
+     * Returns a ReadonlyMap compatible with the legacy RuleRegistry type.
+     */
+    toReadonlyMap(): ReadonlyMap<string, RuleRegistryEntry>;
+    /**
+     * Total number of registered rules.
+     */
+    get size(): number;
+}
+/**
+ * Returns the global registry, creating it on first call.
+ */
+declare const getGlobalRegistry: () => RuleRegistry;
+/**
+ * Resets the global registry to a fresh empty instance.
+ *
+ * FOR TESTS ONLY — never call this in production code.
+ * Allows isolated unit tests that register their own rules without
+ * interfering with the global built-in rules.
+ */
+declare const resetGlobalRegistry: () => void;
+/**
+ * Check if a rule exists in the global registry.
+ */
+declare const isKnownRule: (name: string) => boolean;
+/**
+ * Get rule metadata by name from the global registry.
+ */
+declare const getRuleMetadata: (name: string) => RuleMetadata | undefined;
+/**
+ * Get all registered rule names from the global registry.
+ */
+declare const getAllRuleNames: () => ReadonlyArray<string>;
+/**
+ * Backward-compatible accessor for the legacy `ruleRegistry` constant.
+ * Returns a ReadonlyMap<string, RuleRegistryEntry> view of the global registry.
+ */
+declare const getRuleRegistryMap: () => ReadonlyMap<string, RuleRegistryEntry>;
+/**
+ * Returns all registered rules as RuleListEntry objects.
+ * Used by the `compass rules` CLI command.
+ */
+declare function getRuleListEntries(): RuleListEntry[];
+
+declare function registerAllBuiltinRules(): void;
+
+/**
+ * High-Performance Engine Adapter
+ *
+ * Bridges the RuleRegistry (plugin boundary) with the single-pass engine
+ * and the legacy orchestrator API. Maintains backward compatibility while
+ * enabling batched rule execution and external plugin registration.
+ *
+ * The mutable bare Map that previously lived here has been replaced by
+ * the global RuleRegistry singleton — see rules/registry/rule-registry.ts.
+ */
+
+/**
+ * Checks if a rule is implemented in the engine.
+ */
+declare const isNewEngineRule: (ruleName: string) => boolean;
+/**
+ * Executes multiple rules in a single AST pass (optimal path).
+ *
+ * All handlers for the given rule names are collected from the global
+ * RuleRegistry (which includes both built-in rules and plugin rules) and
+ * passed to runSinglePassAnalysis() — the AST is walked exactly once.
+ *
+ * @param ruleNames - Rules to execute
+ * @param context   - Rule execution context
+ * @returns Array of RuleResults, one per rule name
+ */
+declare const executeBatchedNewEngineRules: (ruleNames: ReadonlyArray<string>, context: RuleContext) => ReadonlyArray<RuleResult>;
+
+/**
+ * Rule Resolution Pipeline
+ *
+ * Main entry point for resolving rules from config + presets
+ */
+
+/**
+ * Resolve rules from config
+ *
+ * Pipeline:
+ * 1. Load & resolve extends chain
+ * 2. Merge all preset rules (deepest first)
+ * 3. Apply user config rules (highest precedence)
+ * 4. Attach metadata from registry
+ * 5. Filter enabled rules
+ */
+declare const resolveRules: (config: NormalizedAnalyzerConfig, configDir?: string) => Promise<Result<RuleResolutionResult>>;
+/**
+ * Get only enabled rules from resolution result
+ *
+ * Pure function: filters out disabled rules
+ */
+declare const getEnabledRules: (resolvedRules: ResolvedRulesMap) => ResolvedRulesMap;
+/**
+ * Get rules by category
+ *
+ * Pure function: groups rules by category
+ */
+declare const getRulesByCategory: (resolvedRules: ResolvedRulesMap) => ReadonlyMap<string, ReadonlyArray<ResolvedRule>>;
+/**
+ * Get rules by dependency type
+ *
+ * Pure function: groups rules by dependency type
+ */
+declare const getRulesByDependencyType: (resolvedRules: ResolvedRulesMap) => ReadonlyMap<string, ReadonlyArray<ResolvedRule>>;
+
+/**
+ * Preset Loader
+ *
+ * Loads preset configurations from built-in presets or file system
+ */
+
+/**
+ * Load a preset by reference
+ *
+ * Side effect: File I/O (isolated)
+ */
+declare const loadPreset: (reference: PresetReference, configDir?: string) => Promise<Result<PresetConfig>>;
+/**
+ * Resolve extends chain recursively
+ *
+ * Handles: "extends": "recommended"
+ * Handles: "extends": ["recommended", "strict"]
+ * Handles: Nested extends in presets
+ *
+ * Returns presets in order (deepest first)
+ */
+declare const resolveExtendsChain: (extendsValue: string | ReadonlyArray<string> | undefined, configDir: string, path?: ReadonlyArray<string>) => Promise<Result<ReadonlyArray<PresetConfig>>>;
+
+/**
+ * Rule Configuration Normalization
+ *
+ * Pure functions to normalize rule configurations
+ */
+
+/**
+ * Normalize rule config to full format
+ *
+ * Pure function: shorthand → full format
+ */
+declare const normalizeRuleConfig: (config: RuleConfig) => RuleConfigFull;
+/**
+ * Check if a rule is enabled (severity !== 'off')
+ */
+declare const isRuleEnabled: (config: RuleConfig) => boolean;
+/**
+ * Normalize all rules in a rules object
+ *
+ * Pure function: transforms all rule configs to full format
+ */
+declare const normalizeAllRules: (rules: Readonly<Record<string, RuleConfig>>) => ReadonlyMap<string, RuleConfigFull>;
+
+/**
+ * Rule Configuration Merger
+ *
+ * Pure functions to merge rule configurations with proper precedence
+ */
+
+/**
+ * Merge two rule configurations
+ *
+ * Pure function: later config overrides earlier config
+ * Handles both shorthand and full format
+ */
+declare const mergeRuleConfig: (base: RuleConfig, override: RuleConfig) => RuleConfigFull;
+/**
+ * Merge multiple rule configuration objects
+ *
+ * Pure function: later configs override earlier configs
+ * Precedence: rules[0] < rules[1] < ... < rules[n]
+ */
+declare const mergeRulesConfigs: (configs: ReadonlyArray<RulesConfig>) => ReadonlyMap<string, RuleConfigFull>;
+/**
+ * Apply overrides to a base rules configuration
+ *
+ * Pure function: overrides have highest precedence
+ */
+declare const applyOverrides: (base: ReadonlyMap<string, RuleConfigFull>, overrides: RulesConfig) => ReadonlyMap<string, RuleConfigFull>;
+
+/**
+ * Built-in Presets Registry
+ */
+
+/**
+ * Registry of built-in presets
+ */
+declare const builtinPresets: ReadonlyMap<BuiltinPreset, PresetConfig>;
+/**
+ * Check if a preset name is a built-in preset
+ */
+declare const isBuiltinPreset: (name: string) => boolean;
+/**
+ * Get a built-in preset by name
+ */
+declare const getBuiltinPreset: (name: string) => PresetConfig | undefined;
+/**
+ * Returns all preset names that include the given rule.
+ */
+declare function getPresetsForRule(ruleName: string): string[];
+
+/**
+ * Rule Recommendations
+ *
+ * Actionable, one-sentence fix recommendations surfaced in reporter output.
+ * Keys must match the ruleName field on RuleFailure exactly.
+ */
+declare const RECOMMENDATIONS: Readonly<Record<string, string>>;
+/**
+ * Optional before/after code examples for rules that have no auto-fix.
+ *
+ * Keys must match the ruleName field on RuleFailure exactly.
+ * Values are plain multi-line TypeScript strings — no ANSI codes.
+ * The reporter renders them in a styled block below the fix recommendation.
+ */
+declare const CODE_EXAMPLES: Readonly<Record<string, string>>;
+
+/**
+ * Loosely-typed AST node used by migration rules.
+ * Provides minimal structure while allowing dynamic property access
+ * that the oxc-parser AST requires.
+ */
+interface AstNode {
+    readonly type?: string;
+    readonly start?: number;
+    readonly end?: number;
+    readonly span?: {
+        start: number;
+        end: number;
+    };
+    readonly name?: string;
+    readonly value?: unknown;
+    readonly computed?: boolean;
+    readonly operator?: string;
+    readonly accessibility?: string;
+    readonly readonly?: boolean;
+    readonly static?: boolean;
+    readonly kind?: string;
+    readonly expression?: AstNode;
+    readonly callee?: AstNode;
+    readonly object?: AstNode;
+    readonly property?: AstNode;
+    readonly arguments?: AstNode[];
+    readonly properties?: AstNode[];
+    readonly elements?: AstNode[];
+    readonly body?: AstNode | AstNode[] | {
+        body?: AstNode[];
+    };
+    readonly params?: AstNode[] | {
+        items?: AstNode[];
+        elements?: AstNode[];
+    };
+    readonly key?: AstNode;
+    readonly left?: AstNode;
+    readonly right?: AstNode;
+    readonly test?: AstNode;
+    readonly consequent?: AstNode;
+    readonly alternate?: AstNode;
+    readonly argument?: AstNode;
+    readonly decorators?: AstNode[];
+    readonly typeAnnotation?: AstNode;
+    readonly typeName?: AstNode;
+    readonly initializer?: AstNode;
+    readonly parent?: AstNode;
+    [key: string]: unknown;
+}
+type MaybeAstNode = AstNode | null | undefined;
+/**
+ * Unwraps TS wrapper nodes, parentheses, chain expressions, and instantiation wrappers.
+ * Handles all known wrapper node types consistently.
+ */
+declare function unwrapNode(node: AstNode | null | undefined): AstNode | null;
+/**
+ * Checks if a node is a member expression (static, computed, or optional).
+ */
+declare function isMemberExpressionLike(node: AstNode | null | undefined): boolean;
+/**
+ * Gets the statically-resolvable property name from a member expression.
+ * Returns '' if the name cannot be determined.
+ */
+declare function getStaticPropertyName(member: AstNode | null | undefined): string;
+/**
+ * Gets the start offset of a node, handling both oxc-parser span and estree start formats.
+ */
+declare function getNodeStart(node: AstNode | null | undefined): number;
+/**
+ * Checks if a call expression's callee matches a given function name.
+ * Handles both direct calls (`fn()`) and member calls (`obj.fn()`).
+ */
+declare function isCalleeNamed(calleeRaw: AstNode | null | undefined, name: string): boolean;
+/**
+ * Gets the name of a call expression's callee.
+ */
+declare function getCalleeName(callExprRaw: AstNode | null | undefined): string;
+/**
+ * Checks if a call expression is a `.subscribe(...)` call.
+ */
+declare function isSubscribeCall(node: AstNode | null | undefined): boolean;
+/**
+ * Gets a property from an ObjectExpression by key name.
+ */
+declare function getObjectProperty(objExpr: AstNode | null | undefined, name: string): AstNode | null;
+/**
+ * Checks if a node is literal `true`.
+ */
+declare function isLiteralTrue(node: AstNode | null | undefined): boolean;
+/**
+ * Checks if a node is literal `null` or `undefined`.
+ */
+declare function isLiteralNullOrUndefined(node: AstNode | null | undefined): boolean;
+/**
+ * Yields all direct child AST nodes of a given node.
+ *
+ * Uses `for...in` instead of `Object.keys()` to avoid allocating an intermediate
+ * string array for every invocation. AST nodes are plain objects (POJOs) so
+ * inherited enumerable properties are not a concern in practice.
+ *
+ * Skips well-known non-child keys (parent, span, etc.) via a Set for O(1) lookup.
+ */
+declare function childNodes(node: AstNode | null | undefined): Iterable<AstNode>;
+/**
+ * Checks if a method definition is a constructor.
+ */
+declare function isConstructorMethod(def: AstNode | null | undefined): boolean;
+/**
+ * Checks if a member is a method definition.
+ */
+declare function isMethodDefinition(member: AstNode | null | undefined): boolean;
+/**
+ * Gets the constructor member from a class body array.
+ */
+declare function getConstructorMember(classBody: AstNode[]): AstNode | null;
+/**
+ * Gets the method body from a method definition.
+ */
+declare function getMethodBody(def: AstNode | null | undefined): AstNode | null;
+/**
+ * Gets the method name from a method definition.
+ */
+declare function getMethodName(def: AstNode | null | undefined): string;
+/**
+ * Gets the class body as an array from a class node.
+ */
+declare function getClassBody(classNode: AstNode | null | undefined): AstNode[];
+/**
+ * Checks if an effect() call has allowed escape hatches ({ injector } or { manualCleanup: true }).
+ */
+declare function isAllowedEffectCall(callExprRaw: AstNode | null | undefined): boolean;
+/**
+ * Finds all effect() calls in a subtree that are not allowed by escape hatches.
+ */
+declare function findEffectCalls(root: AstNode | null | undefined): AstNode[];
+/**
+ * Gets the callback argument (first arg) from a computed() or effect() call,
+ * if it's an arrow or function expression.
+ */
+declare function getCallbackArg(callExpr: AstNode | null | undefined): AstNode | null;
+/**
+ * Gets the body of a function expression.
+ */
+declare function getFunctionBody(fn: AstNode | null | undefined): AstNode | null;
+/**
+ * Collects import aliases for a given exported name from rxjs imports.
+ * E.g., `import { BehaviorSubject as BS } from 'rxjs'` -> Set(['BehaviorSubject', 'BS'])
+ *
+ * @deprecated Use `collectAllRxjsAliases` instead for better performance — it scans the
+ * source text only once for all requested names instead of once per name.
+ */
+declare function collectRxjsAliases(sourceText: string | undefined, exportedName: string): Set<string>;
+/**
+ * Batch version of collectRxjsAliases — scans source text ONCE for all requested export names.
+ *
+ * Use this instead of calling collectRxjsAliases() per name to avoid redundant regex work.
+ *
+ * @performance O(S × 2) instead of O(S × 2 × N) where N = number of requested names.
+ *   Reduces 6 full-source regex sweeps (e.g. for Subject/ReplaySubject/AsyncSubject) down to 2.
+ */
+declare function collectAllRxjsAliases(sourceText: string | undefined, exportedNames: ReadonlySet<string>): Map<string, Set<string>>;
+/**
+ * The canonical set of RxJS operators that properly scope subscription lifetime.
+ *
+ * Shared between rxjs-no-subscribe-in-component and rxjs-require-takeUntilDestroyed rules
+ * to guarantee consistent teardown detection without duplicating the operator list.
+ */
+declare const VALID_TEARDOWN_OPERATORS: Set<string>;
+/**
+ * Extracts the operator name from a single pipe() argument node.
+ */
+declare function getOperatorNameFromPipeArg(arg: AstNode | null | undefined): string;
+/**
+ * Returns true if the given pipe() call contains at least one valid teardown operator.
+ */
+declare function hasTeardownInPipeCall(pipeCall: AstNode): boolean;
+/**
+ * Walks the receiver chain of a .subscribe() call looking for a .pipe() call that
+ * contains at least one valid teardown operator.
+ *
+ * @example `source$.pipe(takeUntilDestroyed(destroyRef)).subscribe(...)` → true
+ */
+declare function hasTeardownInReceiverChain(receiverExpr: AstNode | null | undefined): boolean;
+/**
+ * Computes absolute offset for template expressions, accounting for inline template offset.
+ */
+declare function getTemplateAbsoluteOffset(context: {
+    template?: {
+        templateStartOffset?: number;
+    };
+}, nodeStart: number): number;
+/**
+ * Walks a .subscribe() receiver chain past any .pipe() calls to the actual
+ * source observable call expression.
+ *
+ * @example
+ *   this.svc.getUser(id).pipe(map(u => u.name)).subscribe(...)
+ *   receiverExpr = pipe(map(...)) CallExpression
+ *   returns      = this.svc.getUser(id) CallExpression
+ *
+ * Returns null when the chain root is not a recognisable CallExpression.
+ */
+declare function findObservableSourceCall(receiverExpr: AstNode | null | undefined): AstNode | null;
+/**
+ * Returns true if a call expression is a likely auto-completing HTTP observable.
+ *
+ * Detects two unambiguous patterns (conservative — avoids false negatives on
+ * legitimate long-lived streams):
+ *
+ *   1. Direct HttpClient verb call:
+ *        `this.http.get(url)`, `this.httpClient.post(url, body)`
+ *
+ *   2. Service/API method with HTTP-action prefix AND at least one argument:
+ *        `this.userSvc.getUser(id)`, `this.api.postComment(body)`,
+ *        `this.repo.deleteItem(id)`, `this.gateway.fetchReport(params)`
+ *
+ * Both patterns emit once and complete — they do not need takeUntilDestroyed.
+ */
+declare function isLikelyHttpObservable(sourceCall: AstNode | null | undefined): boolean;
+/**
+ * Gets parameters array from a function node, handling various AST formats.
+ */
+declare function getParamsArray(funcNode: AstNode | null | undefined): AstNode[];
+/**
+ * Gets the identifier name from a parameter node (handles AssignmentPattern, RestElement, TSParameterProperty).
+ */
+declare function getParamIdentifierName(param: AstNode | null | undefined): string;
+/**
+ * Gets the type name from a parameter's type annotation (handles TSParameterProperty).
+ */
+declare function getParamTypeName(param: AstNode | null | undefined): string;
+/**
+ * Maps an Oxc AST node to a TypeScript AST node and fetches its symbol from the TypeChecker.
+ * Uses position-based lookup since Oxc and TS nodes do not share identity.
+ */
+declare function getTsSymbolAtNode(oxcNode: AstNode | null | undefined, context: RuleContext): typescript.Symbol | undefined;
+/**
+ * Checks if a symbol belongs to a well-known Angular type or carries an @Injectable decorator.
+ */
+declare function isLikelyAngularInjectableSymbol(symbol: typescript.Symbol | undefined): boolean;
+
+declare const rules = "@ngcompass/rules";
+
+export { type AstNode, CODE_EXAMPLES, type MaybeAstNode, RECOMMENDATIONS, type RegisterOptions, type RulePlugin, RuleRegistry, VALID_TEARDOWN_OPERATORS, applyOverrides, builtinPresets, childNodes, collectAllRxjsAliases, collectRxjsAliases, componentNoManualDetectChangesRule, executeBatchedNewEngineRules, findEffectCalls, findObservableSourceCall, getAllRuleNames, getBuiltinPreset, getCallbackArg, getCalleeName, getClassBody, getConstructorMember, getEnabledRules, getFunctionBody, getGlobalRegistry, getMethodBody, getMethodName, getNodeStart, getObjectProperty, getOperatorNameFromPipeArg, getParamIdentifierName, getParamTypeName, getParamsArray, getPresetsForRule, getRuleListEntries, getRuleMetadata, getRulesByCategory, getRulesByDependencyType, getStaticPropertyName, getTemplateAbsoluteOffset, getTsSymbolAtNode, hasManualTeardownInNgOnDestroy, hasTeardownInPipeCall, hasTeardownInReceiverChain, isAllowedEffectCall, isBuiltinPreset, isCalleeNamed, isConstructorMethod, isKnownRule, isLikelyAngularInjectableSymbol, isLikelyHttpObservable, isLiteralNullOrUndefined, isLiteralTrue, isMemberExpressionLike, isMethodDefinition, isNewEngineRule, isRuleEnabled, isSubscribeCall, loadPreset, mergeRuleConfig, mergeRulesConfigs, noBypassSanitizationRule, noDocumentAccessRule, normalizeAllRules, normalizeRuleConfig, preferAfterRenderOverAfterViewInitRule, preferInjectRule, preferOnPushRule, registerAllBuiltinRules, resetGlobalRegistry, resolveExtendsChain, resolveRules, getRuleRegistryMap as ruleRegistry, rules, rxjsAvoidSubjectRule, rxjsNoNestedSubscribeRule, rxjsNoSubscribeInComponentRule, rxjsPreferToSignalRule, rxjsRequireTakeUntilDestroyedRule, signalAvoidUntrackedRule, signalEffectDestroyScopedRule, signalNoSideEffectsInComputedRule, signalPreferComputedRule, signalPreferInputSignalRule, signalPreferModelRule, signalPreferOutputFunctionRule, specNoFocusedTestRule, templateNoArrayLiteralBindingRule, templateNoAsyncPipeDuplicationRule, templateNoCallExpressionRule, templateNoObjectLiteralBindingRule, templateNoUnsafeBindingsRule, templatePreferControlFlowRule, templateTrackByRequiredRule, toSignalRequireInitialValueRule, unwrapNode };