eslint-plugin-typefest 1.0.1

package/dist/_internal/set-membership.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Check whether a Set contains a candidate value while intentionally exposing
+ * only plain-boolean semantics at call sites.
+ */
+export declare const setContainsValue: <Type>(set: ReadonlySet<Type>, item: Type) => boolean;
+//# sourceMappingURL=set-membership.d.ts.map

package/dist/_internal/set-membership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-membership.d.ts","sourceRoot":"","sources":["../../src/_internal/set-membership.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,IAAI,EACjC,KAAK,WAAW,CAAC,IAAI,CAAC,EACtB,MAAM,IAAI,KACX,OAAkC,CAAC"}

package/dist/_internal/set-membership.js

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * Shared helpers for explicit boolean Set membership checks.
+ */
+import { setHas } from "ts-extras";
+/**
+ * Check whether a Set contains a candidate value while intentionally exposing
+ * only plain-boolean semantics at call sites.
+ */
+export const setContainsValue = (set, item) => setHas(set, item);
+//# sourceMappingURL=set-membership.js.map

package/dist/_internal/set-membership.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-membership.js","sourceRoot":"","sources":["../../src/_internal/set-membership.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC5B,GAAsB,EACtB,IAAU,EACH,EAAE,CAAC,MAAM,CAAO,GAAG,EAAE,IAAI,CAAC,CAAC"}

package/dist/_internal/text-character.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @packageDocumentation
+ * Shared character classification helpers for lightweight parser/token logic.
+ */
+/**
+ * Determine whether a single-character string is an ASCII identifier part.
+ *
+ * @remarks
+ * This intentionally mirrors lightweight token checks used by internal string
+ * parsers. It does not attempt to model full Unicode ECMAScript identifiers.
+ */
+export declare const isAsciiIdentifierPartCharacter: (character: string) => boolean;
+/**
+ * Determine whether a single-character string should be treated as whitespace
+ * in internal import/token parsing helpers.
+ */
+export declare const isKnownWhitespaceCharacter: (character: string) => boolean;
+//# sourceMappingURL=text-character.d.ts.map

package/dist/_internal/text-character.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-character.d.ts","sourceRoot":"","sources":["../../src/_internal/text-character.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAyBH;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,GAAI,WAAW,MAAM,KAAG,OAoBlE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GAAI,WAAW,MAAM,KAAG,OAuB9D,CAAC"}

package/dist/_internal/text-character.js

@@ -0,0 +1,69 @@
+/**
+ * @packageDocumentation
+ * Shared character classification helpers for lightweight parser/token logic.
+ */
+import { isDefined } from "ts-extras";
+const ASCII_DIGIT_ZERO = 48;
+const ASCII_DIGIT_NINE = 57;
+const ASCII_UPPERCASE_A = 65;
+const ASCII_UPPERCASE_Z = 90;
+const ASCII_LOWERCASE_A = 97;
+const ASCII_LOWERCASE_Z = 122;
+const ASCII_TAB = 9;
+const ASCII_LINE_FEED = 10;
+const ASCII_VERTICAL_TAB = 11;
+const ASCII_FORM_FEED = 12;
+const ASCII_CARRIAGE_RETURN = 13;
+const ASCII_SPACE = 32;
+const NO_BREAK_SPACE = 160;
+const BYTE_ORDER_MARK = 65_279;
+const LINE_SEPARATOR = 8232;
+const PARAGRAPH_SEPARATOR = 8233;
+const DOLLAR_SIGN = "$";
+const UNDERSCORE = "_";
+/**
+ * Determine whether a single-character string is an ASCII identifier part.
+ *
+ * @remarks
+ * This intentionally mirrors lightweight token checks used by internal string
+ * parsers. It does not attempt to model full Unicode ECMAScript identifiers.
+ */
+export const isAsciiIdentifierPartCharacter = (character) => {
+    if (character === DOLLAR_SIGN || character === UNDERSCORE) {
+        return true;
+    }
+    if (character.length === 0) {
+        return false;
+    }
+    const codePoint = character.codePointAt(0);
+    if (!isDefined(codePoint)) {
+        return false;
+    }
+    return ((codePoint >= ASCII_DIGIT_ZERO && codePoint <= ASCII_DIGIT_NINE) ||
+        (codePoint >= ASCII_UPPERCASE_A && codePoint <= ASCII_UPPERCASE_Z) ||
+        (codePoint >= ASCII_LOWERCASE_A && codePoint <= ASCII_LOWERCASE_Z));
+};
+/**
+ * Determine whether a single-character string should be treated as whitespace
+ * in internal import/token parsing helpers.
+ */
+export const isKnownWhitespaceCharacter = (character) => {
+    if (character.length === 0) {
+        return false;
+    }
+    const codePoint = character.codePointAt(0);
+    if (!isDefined(codePoint)) {
+        return false;
+    }
+    return (codePoint === ASCII_TAB ||
+        codePoint === ASCII_LINE_FEED ||
+        codePoint === ASCII_VERTICAL_TAB ||
+        codePoint === ASCII_FORM_FEED ||
+        codePoint === ASCII_CARRIAGE_RETURN ||
+        codePoint === ASCII_SPACE ||
+        codePoint === NO_BREAK_SPACE ||
+        codePoint === BYTE_ORDER_MARK ||
+        codePoint === LINE_SEPARATOR ||
+        codePoint === PARAGRAPH_SEPARATOR);
+};
+//# sourceMappingURL=text-character.js.map

package/dist/_internal/text-character.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-character.js","sourceRoot":"","sources":["../../src/_internal/text-character.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC,MAAM,gBAAgB,GAAG,EAAW,CAAC;AACrC,MAAM,gBAAgB,GAAG,EAAW,CAAC;AACrC,MAAM,iBAAiB,GAAG,EAAW,CAAC;AACtC,MAAM,iBAAiB,GAAG,EAAW,CAAC;AACtC,MAAM,iBAAiB,GAAG,EAAW,CAAC;AACtC,MAAM,iBAAiB,GAAG,GAAY,CAAC;AAEvC,MAAM,SAAS,GAAG,CAAU,CAAC;AAC7B,MAAM,eAAe,GAAG,EAAW,CAAC;AACpC,MAAM,kBAAkB,GAAG,EAAW,CAAC;AACvC,MAAM,eAAe,GAAG,EAAW,CAAC;AACpC,MAAM,qBAAqB,GAAG,EAAW,CAAC;AAC1C,MAAM,WAAW,GAAG,EAAW,CAAC;AAChC,MAAM,cAAc,GAAG,GAAY,CAAC;AACpC,MAAM,eAAe,GAAG,MAAe,CAAC;AACxC,MAAM,cAAc,GAAG,IAAa,CAAC;AACrC,MAAM,mBAAmB,GAAG,IAAa,CAAC;AAE1C,MAAM,WAAW,GAAG,GAAY,CAAC;AACjC,MAAM,UAAU,GAAG,GAAY,CAAC;AAEhC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,SAAiB,EAAW,EAAE;IACzE,IAAI,SAAS,KAAK,WAAW,IAAI,SAAS,KAAK,UAAU,EAAE,CAAC;QACxD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,SAAS,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAE3C,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC;QACxB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,OAAO,CACH,CAAC,SAAS,IAAI,gBAAgB,IAAI,SAAS,IAAI,gBAAgB,CAAC;QAChE,CAAC,SAAS,IAAI,iBAAiB,IAAI,SAAS,IAAI,iBAAiB,CAAC;QAClE,CAAC,SAAS,IAAI,iBAAiB,IAAI,SAAS,IAAI,iBAAiB,CAAC,CACrE,CAAC;AACN,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,SAAiB,EAAW,EAAE;IACrE,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,SAAS,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAE3C,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC;QACxB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,OAAO,CACH,SAAS,KAAK,SAAS;QACvB,SAAS,KAAK,eAAe;QAC7B,SAAS,KAAK,kBAAkB;QAChC,SAAS,KAAK,eAAe;QAC7B,SAAS,KAAK,qBAAqB;QACnC,SAAS,KAAK,WAAW;QACzB,SAAS,KAAK,cAAc;QAC5B,SAAS,KAAK,eAAe;QAC7B,SAAS,KAAK,cAAc;QAC5B,SAAS,KAAK,mBAAmB,CACpC,CAAC;AACN,CAAC,CAAC"}

package/dist/_internal/throw-consequent.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @packageDocumentation
+ * Shared helpers for extracting throw-only `if` consequents.
+ */
+import type { TSESTree } from "@typescript-eslint/utils";
+/**
+ * Check whether an `if` consequent contains only a throw statement.
+ *
+ * @param node - Consequent statement to inspect.
+ *
+ * @returns `true` for `throw ...` and `{ throw ... }` shapes.
+ */
+export declare const isThrowOnlyConsequent: (node: Readonly<TSESTree.Statement>) => boolean;
+/**
+ * Extract the throw statement from a throw-only consequent.
+ *
+ * @param node - Consequent statement to inspect.
+ *
+ * @returns Throw statement when present; otherwise `null`.
+ */
+export declare const getThrowStatementFromConsequent: (node: Readonly<TSESTree.Statement>) => null | TSESTree.ThrowStatement;
+//# sourceMappingURL=throw-consequent.d.ts.map

package/dist/_internal/throw-consequent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throw-consequent.d.ts","sourceRoot":"","sources":["../../src/_internal/throw-consequent.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AA4BzD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAC9B,MAAM,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,KACnC,OAOF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,GACxC,MAAM,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,KACnC,IAAI,GAAG,QAAQ,CAAC,cAOlB,CAAC"}

package/dist/_internal/throw-consequent.js

@@ -0,0 +1,48 @@
+import { arrayFirst } from "ts-extras";
+/**
+ * Extract the single throw statement from a block consequent when present.
+ *
+ * @param node - Consequent statement candidate.
+ *
+ * @returns The throw statement when the consequent is exactly `{ throw ... }`;
+ *   otherwise `null`.
+ */
+const getSingleThrowFromBlockConsequent = (node) => {
+    if (node.type !== "BlockStatement" || node.body.length !== 1) {
+        return null;
+    }
+    const firstStatement = arrayFirst(node.body);
+    if (firstStatement?.type !== "ThrowStatement") {
+        return null;
+    }
+    return firstStatement;
+};
+/**
+ * Check whether an `if` consequent contains only a throw statement.
+ *
+ * @param node - Consequent statement to inspect.
+ *
+ * @returns `true` for `throw ...` and `{ throw ... }` shapes.
+ */
+export const isThrowOnlyConsequent = (node) => {
+    if (node.type === "ThrowStatement") {
+        return true;
+    }
+    /* v8 ignore next 2 -- defensive sparse-array guard for malformed synthetic AST nodes. */
+    return getSingleThrowFromBlockConsequent(node) !== null;
+};
+/**
+ * Extract the throw statement from a throw-only consequent.
+ *
+ * @param node - Consequent statement to inspect.
+ *
+ * @returns Throw statement when present; otherwise `null`.
+ */
+export const getThrowStatementFromConsequent = (node) => {
+    if (node.type === "ThrowStatement") {
+        return node;
+    }
+    /* v8 ignore next 2 -- guarded by isThrowOnlyConsequent before this helper is invoked in rule flow. */
+    return getSingleThrowFromBlockConsequent(node);
+};
+//# sourceMappingURL=throw-consequent.js.map

package/dist/_internal/throw-consequent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throw-consequent.js","sourceRoot":"","sources":["../../src/_internal/throw-consequent.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC;;;;;;;GAOG;AACH,MAAM,iCAAiC,GAAG,CACtC,IAAkC,EACJ,EAAE;IAChC,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3D,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,MAAM,cAAc,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAE7C,IAAI,cAAc,EAAE,IAAI,KAAK,gBAAgB,EAAE,CAAC;QAC5C,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,OAAO,cAAc,CAAC;AAC1B,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACjC,IAAkC,EAC3B,EAAE;IACT,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,yFAAyF;IACzF,OAAO,iCAAiC,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC;AAC5D,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAC3C,IAAkC,EACJ,EAAE;IAChC,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,sGAAsG;IACtG,OAAO,iCAAiC,CAAC,IAAI,CAAC,CAAC;AACnD,CAAC,CAAC"}

package/dist/_internal/throw-type-error.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ * Shared helpers for validating canonical `throw new TypeError(...)` shapes.
+ */
+import type { TSESLint, TSESTree } from "@typescript-eslint/utils";
+import type { UnknownArray } from "type-fest";
+/**
+ * Extract the single constructor argument from `throw new TypeError(...)`
+ * statements when the constructor resolves to the global `TypeError` binding.
+ *
+ * @param options - Rule context and throw statement candidate.
+ *
+ * @returns The single non-spread constructor argument; otherwise `null`.
+ */
+export declare const getSingleGlobalTypeErrorArgument: <MessageIds extends string, Options extends Readonly<UnknownArray>>({ context, throwStatement, }: Readonly<{
+    context: Readonly<TSESLint.RuleContext<MessageIds, Options>>;
+    throwStatement: Readonly<TSESTree.ThrowStatement>;
+}>) => null | TSESTree.Expression;
+//# sourceMappingURL=throw-type-error.d.ts.map

package/dist/_internal/throw-type-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throw-type-error.d.ts","sourceRoot":"","sources":["../../src/_internal/throw-type-error.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAI9C;;;;;;;GAOG;AACH,eAAO,MAAM,gCAAgC,GACzC,UAAU,SAAS,MAAM,EACzB,OAAO,SAAS,QAAQ,CAAC,YAAY,CAAC,EACxC,8BAGC,QAAQ,CAAC;IACR,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7D,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;CACrD,CAAC,KAAG,IAAI,GAAG,QAAQ,CAAC,UAqBpB,CAAC"}

package/dist/_internal/throw-type-error.js

@@ -0,0 +1,24 @@
+import { isGlobalIdentifierNamed } from "./typed-rule.js";
+/**
+ * Extract the single constructor argument from `throw new TypeError(...)`
+ * statements when the constructor resolves to the global `TypeError` binding.
+ *
+ * @param options - Rule context and throw statement candidate.
+ *
+ * @returns The single non-spread constructor argument; otherwise `null`.
+ */
+export const getSingleGlobalTypeErrorArgument = ({ context, throwStatement, }) => {
+    if (throwStatement.argument.type !== "NewExpression" ||
+        throwStatement.argument.callee.type !== "Identifier" ||
+        throwStatement.argument.callee.name !== "TypeError" ||
+        !isGlobalIdentifierNamed(context, throwStatement.argument.callee, "TypeError") ||
+        throwStatement.argument.arguments.length !== 1) {
+        return null;
+    }
+    const [firstArgument] = throwStatement.argument.arguments;
+    if (!firstArgument || firstArgument.type === "SpreadElement") {
+        return null;
+    }
+    return firstArgument;
+};
+//# sourceMappingURL=throw-type-error.js.map

package/dist/_internal/throw-type-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throw-type-error.js","sourceRoot":"","sources":["../../src/_internal/throw-type-error.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAG9C,EACE,OAAO,EACP,cAAc,GAIhB,EAA8B,EAAE;IAC9B,IACI,cAAc,CAAC,QAAQ,CAAC,IAAI,KAAK,eAAe;QAChD,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY;QACpD,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,KAAK,WAAW;QACnD,CAAC,uBAAuB,CACpB,OAAO,EACP,cAAc,CAAC,QAAQ,CAAC,MAAM,EAC9B,WAAW,CACd;QACD,cAAc,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAChD,CAAC;QACC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,QAAQ,CAAC,SAAS,CAAC;IAC1D,IAAI,CAAC,aAAa,IAAI,aAAa,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;QAC3D,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,OAAO,aAAa,CAAC;AACzB,CAAC,CAAC"}

package/dist/_internal/type-checker-compat.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @packageDocumentation
+ * Compatibility wrappers for optional TypeScript TypeChecker APIs.
+ */
+import type ts from "typescript";
+/**
+ * Read `checker.getApparentType` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Apparent type when available; otherwise `undefined`.
+ */
+export declare const getTypeCheckerApparentType: (checker: Readonly<ts.TypeChecker>, type: Readonly<ts.Type>) => ts.Type | undefined;
+/**
+ * Read `checker.getBaseTypes` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Base types when available; otherwise `undefined`.
+ */
+export declare const getTypeCheckerBaseTypes: (checker: Readonly<ts.TypeChecker>, type: Readonly<ts.Type>) => readonly ts.BaseType[] | undefined;
+/**
+ * Read `checker.getStringType` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ *
+ * @returns Primitive string type when available; otherwise `undefined`.
+ */
+export declare const getTypeCheckerStringType: (checker: Readonly<ts.TypeChecker>) => ts.Type | undefined;
+/**
+ * Read `checker.isTypeAssignableTo` when the host TypeScript version provides
+ * it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param source - Candidate source type.
+ * @param target - Candidate target type.
+ *
+ * @returns Assignability result when available; otherwise `undefined`.
+ */
+export declare const getTypeCheckerIsTypeAssignableToResult: (checker: Readonly<ts.TypeChecker>, source: Readonly<ts.Type>, target: Readonly<ts.Type>) => boolean | undefined;
+/**
+ * Read `checker.getBaseConstraintOfType` when the host TypeScript version
+ * provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Base-constraint type when available; otherwise `undefined`.
+ */
+export declare const getTypeCheckerBaseConstraintType: (checker: Readonly<ts.TypeChecker>, type: Readonly<ts.Type>) => ts.Type | undefined;
+/**
+ * Read `checker.isArrayType` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Array-type result when available; otherwise `undefined`.
+ */
+export declare const getTypeCheckerIsArrayTypeResult: (checker: Readonly<ts.TypeChecker>, type: Readonly<ts.Type>) => boolean | undefined;
+/**
+ * Read `checker.isTupleType` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Tuple-type result when available; otherwise `undefined`.
+ */
+export declare const getTypeCheckerIsTupleTypeResult: (checker: Readonly<ts.TypeChecker>, type: Readonly<ts.Type>) => boolean | undefined;
+/**
+ * Read `checker.getTypeArguments` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Type arguments when available; otherwise `undefined`.
+ */
+export declare const getTypeCheckerTypeArguments: (checker: Readonly<ts.TypeChecker>, type: Readonly<ts.Type>) => readonly ts.Type[] | undefined;
+//# sourceMappingURL=type-checker-compat.d.ts.map

package/dist/_internal/type-checker-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checker-compat.d.ts","sourceRoot":"","sources":["../../src/_internal/type-checker-compat.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAKjC;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,GACnC,SAAS,QAAQ,CAAC,EAAE,CAAC,WAAW,CAAC,EACjC,MAAM,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,KACxB,EAAE,CAAC,IAAI,GAAG,SAQZ,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,GAChC,SAAS,QAAQ,CAAC,EAAE,CAAC,WAAW,CAAC,EACjC,MAAM,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,KACxB,SAAS,EAAE,CAAC,QAAQ,EAAE,GAAG,SAQ3B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACjC,SAAS,QAAQ,CAAC,EAAE,CAAC,WAAW,CAAC,KAClC,EAAE,CAAC,IAAI,GAAG,SAQZ,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,sCAAsC,GAC/C,SAAS,QAAQ,CAAC,EAAE,CAAC,WAAW,CAAC,EACjC,QAAQ,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,EACzB,QAAQ,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,KAC1B,OAAO,GAAG,SAeZ,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,gCAAgC,GACzC,SAAS,QAAQ,CAAC,EAAE,CAAC,WAAW,CAAC,EACjC,MAAM,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,KACxB,EAAE,CAAC,IAAI,GAAG,SAaZ,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,GACxC,SAAS,QAAQ,CAAC,EAAE,CAAC,WAAW,CAAC,EACjC,MAAM,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,KACxB,OAAO,GAAG,SAQZ,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,GACxC,SAAS,QAAQ,CAAC,EAAE,CAAC,WAAW,CAAC,EACjC,MAAM,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,KACxB,OAAO,GAAG,SAQZ,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,GACpC,SAAS,QAAQ,CAAC,EAAE,CAAC,WAAW,CAAC,EACjC,MAAM,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,KACxB,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,SAcvB,CAAC"}

package/dist/_internal/type-checker-compat.js

@@ -0,0 +1,104 @@
+import { isTypeReferenceType } from "@typescript-eslint/type-utils";
+import { safeCastTo } from "ts-extras";
+/**
+ * Read `checker.getApparentType` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Apparent type when available; otherwise `undefined`.
+ */
+export const getTypeCheckerApparentType = (checker, type) => {
+    const checkerWithApparentType = safeCastTo(checker);
+    return checkerWithApparentType.getApparentType?.call(checker, type);
+};
+/**
+ * Read `checker.getBaseTypes` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Base types when available; otherwise `undefined`.
+ */
+export const getTypeCheckerBaseTypes = (checker, type) => {
+    const checkerWithBaseTypes = checker;
+    return checkerWithBaseTypes.getBaseTypes?.call(checker, type);
+};
+/**
+ * Read `checker.getStringType` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ *
+ * @returns Primitive string type when available; otherwise `undefined`.
+ */
+export const getTypeCheckerStringType = (checker) => {
+    const checkerWithStringType = safeCastTo(checker);
+    return checkerWithStringType.getStringType?.call(checker);
+};
+/**
+ * Read `checker.isTypeAssignableTo` when the host TypeScript version provides
+ * it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param source - Candidate source type.
+ * @param target - Candidate target type.
+ *
+ * @returns Assignability result when available; otherwise `undefined`.
+ */
+export const getTypeCheckerIsTypeAssignableToResult = (checker, source, target) => {
+    const checkerWithAssignable = safeCastTo(checker);
+    return checkerWithAssignable.isTypeAssignableTo?.call(checker, source, target);
+};
+/**
+ * Read `checker.getBaseConstraintOfType` when the host TypeScript version
+ * provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Base-constraint type when available; otherwise `undefined`.
+ */
+export const getTypeCheckerBaseConstraintType = (checker, type) => {
+    const checkerWithBaseConstraint = safeCastTo(checker);
+    return checkerWithBaseConstraint.getBaseConstraintOfType?.call(checker, type);
+};
+/**
+ * Read `checker.isArrayType` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Array-type result when available; otherwise `undefined`.
+ */
+export const getTypeCheckerIsArrayTypeResult = (checker, type) => {
+    const checkerWithArrayType = safeCastTo(checker);
+    return checkerWithArrayType.isArrayType?.call(checker, type);
+};
+/**
+ * Read `checker.isTupleType` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Tuple-type result when available; otherwise `undefined`.
+ */
+export const getTypeCheckerIsTupleTypeResult = (checker, type) => {
+    const checkerWithTupleType = safeCastTo(checker);
+    return checkerWithTupleType.isTupleType?.call(checker, type);
+};
+/**
+ * Read `checker.getTypeArguments` when the host TypeScript version provides it.
+ *
+ * @param checker - TypeScript type checker.
+ * @param type - Candidate type.
+ *
+ * @returns Type arguments when available; otherwise `undefined`.
+ */
+export const getTypeCheckerTypeArguments = (checker, type) => {
+    if (!isTypeReferenceType(type)) {
+        return undefined;
+    }
+    const checkerWithTypeArguments = safeCastTo(checker);
+    return checkerWithTypeArguments.getTypeArguments?.call(checker, type);
+};
+//# sourceMappingURL=type-checker-compat.js.map

package/dist/_internal/type-checker-compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checker-compat.js","sourceRoot":"","sources":["../../src/_internal/type-checker-compat.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CACtC,OAAiC,EACjC,IAAuB,EACJ,EAAE;IACrB,MAAM,uBAAuB,GAAG,UAAU,CAIxC,OAAO,CAAC,CAAC;IAEX,OAAO,uBAAuB,CAAC,eAAe,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACxE,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CACnC,OAAiC,EACjC,IAAuB,EACW,EAAE;IACpC,MAAM,oBAAoB,GAAG,OAI5B,CAAC;IAEF,OAAO,oBAAoB,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAClE,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CACpC,OAAiC,EACd,EAAE;IACrB,MAAM,qBAAqB,GAAG,UAAU,CAItC,OAAO,CAAC,CAAC;IAEX,OAAO,qBAAqB,CAAC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;AAC9D,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAAG,CAClD,OAAiC,EACjC,MAAyB,EACzB,MAAyB,EACN,EAAE;IACrB,MAAM,qBAAqB,GAAG,UAAU,CAOtC,OAAO,CAAC,CAAC;IAEX,OAAO,qBAAqB,CAAC,kBAAkB,EAAE,IAAI,CACjD,OAAO,EACP,MAAM,EACN,MAAM,CACT,CAAC;AACN,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAC5C,OAAiC,EACjC,IAAuB,EACJ,EAAE;IACrB,MAAM,yBAAyB,GAAG,UAAU,CAM1C,OAAO,CAAC,CAAC;IAEX,OAAO,yBAAyB,CAAC,uBAAuB,EAAE,IAAI,CAC1D,OAAO,EACP,IAAI,CACP,CAAC;AACN,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAC3C,OAAiC,EACjC,IAAuB,EACJ,EAAE;IACrB,MAAM,oBAAoB,GAAG,UAAU,CAIrC,OAAO,CAAC,CAAC;IAEX,OAAO,oBAAoB,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACjE,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAC3C,OAAiC,EACjC,IAAuB,EACJ,EAAE;IACrB,MAAM,oBAAoB,GAAG,UAAU,CAIrC,OAAO,CAAC,CAAC;IAEX,OAAO,oBAAoB,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACjE,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CACvC,OAAiC,EACjC,IAAuB,EACO,EAAE;IAChC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,MAAM,wBAAwB,GAAG,UAAU,CAMzC,OAAO,CAAC,CAAC;IAEX,OAAO,wBAAwB,CAAC,gBAAgB,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC1E,CAAC,CAAC"}

package/dist/_internal/type-predicate-autofix-safety.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @packageDocumentation
+ * Conservative safety checks for autofixes that introduce type predicates.
+ */
+import type { TSESTree } from "@typescript-eslint/utils";
+/**
+ * Determine whether a call-expression replacement to a type-predicate helper is
+ * safe to apply as an autofix.
+ *
+ * @remarks
+ * Type-predicate helpers (for example `setHas`) can change control-flow
+ * narrowing in boolean guard expressions. This check intentionally disables
+ * autofix in those contexts and leaves a diagnostic for manual review.
+ */
+export declare const isTypePredicateExpressionAutofixSafe: (node: Readonly<TSESTree.Expression>) => boolean;
+/**
+ * Backward-compatible alias for call-expression-based callers.
+ */
+export declare const isTypePredicateAutofixSafe: (node: Readonly<TSESTree.CallExpression>) => boolean;
+//# sourceMappingURL=type-predicate-autofix-safety.d.ts.map

package/dist/_internal/type-predicate-autofix-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-predicate-autofix-safety.d.ts","sourceRoot":"","sources":["../../src/_internal/type-predicate-autofix-safety.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAKzD;;;;;;;;GAQG;AACH,eAAO,MAAM,oCAAoC,GAC7C,MAAM,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,KACpC,OA+DF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,GACnC,MAAM,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,KACxC,OAAqD,CAAC"}

package/dist/_internal/type-predicate-autofix-safety.js

@@ -0,0 +1,58 @@
+import { getParentNode } from "./ast-node.js";
+import { isTransparentExpressionWrapper } from "./value-rewrite-autofix-safety.js";
+/**
+ * Determine whether a call-expression replacement to a type-predicate helper is
+ * safe to apply as an autofix.
+ *
+ * @remarks
+ * Type-predicate helpers (for example `setHas`) can change control-flow
+ * narrowing in boolean guard expressions. This check intentionally disables
+ * autofix in those contexts and leaves a diagnostic for manual review.
+ */
+export const isTypePredicateExpressionAutofixSafe = (node) => {
+    let currentNode = node;
+    while (true) {
+        const parentNode = getParentNode(currentNode);
+        if (parentNode === undefined) {
+            return true;
+        }
+        if (isTransparentExpressionWrapper(parentNode, currentNode)) {
+            currentNode = parentNode;
+            continue;
+        }
+        if (parentNode.type === "UnaryExpression" &&
+            parentNode.operator === "!" &&
+            parentNode.argument === currentNode) {
+            return false;
+        }
+        if (parentNode.type === "LogicalExpression" &&
+            (parentNode.left === currentNode ||
+                parentNode.right === currentNode)) {
+            return false;
+        }
+        if (parentNode.type === "ConditionalExpression" &&
+            parentNode.test === currentNode) {
+            return false;
+        }
+        if ((parentNode.type === "DoWhileStatement" ||
+            parentNode.type === "IfStatement" ||
+            parentNode.type === "WhileStatement") &&
+            parentNode.test === currentNode) {
+            return false;
+        }
+        if (parentNode.type === "ForStatement" &&
+            parentNode.test === currentNode) {
+            return false;
+        }
+        if (parentNode.type === "SwitchCase" &&
+            parentNode.test === currentNode) {
+            return false;
+        }
+        return true;
+    }
+};
+/**
+ * Backward-compatible alias for call-expression-based callers.
+ */
+export const isTypePredicateAutofixSafe = (node) => isTypePredicateExpressionAutofixSafe(node);
+//# sourceMappingURL=type-predicate-autofix-safety.js.map

package/dist/_internal/type-predicate-autofix-safety.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-predicate-autofix-safety.js","sourceRoot":"","sources":["../../src/_internal/type-predicate-autofix-safety.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AAEnF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAChD,IAAmC,EAC5B,EAAE;IACT,IAAI,WAAW,GAA4B,IAAI,CAAC;IAEhD,OAAO,IAAI,EAAE,CAAC;QACV,MAAM,UAAU,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;QAE9C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC;QAChB,CAAC;QAED,IAAI,8BAA8B,CAAC,UAAU,EAAE,WAAW,CAAC,EAAE,CAAC;YAC1D,WAAW,GAAG,UAAU,CAAC;YACzB,SAAS;QACb,CAAC;QAED,IACI,UAAU,CAAC,IAAI,KAAK,iBAAiB;YACrC,UAAU,CAAC,QAAQ,KAAK,GAAG;YAC3B,UAAU,CAAC,QAAQ,KAAK,WAAW,EACrC,CAAC;YACC,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,IACI,UAAU,CAAC,IAAI,KAAK,mBAAmB;YACvC,CAAC,UAAU,CAAC,IAAI,KAAK,WAAW;gBAC5B,UAAU,CAAC,KAAK,KAAK,WAAW,CAAC,EACvC,CAAC;YACC,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,IACI,UAAU,CAAC,IAAI,KAAK,uBAAuB;YAC3C,UAAU,CAAC,IAAI,KAAK,WAAW,EACjC,CAAC;YACC,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,IACI,CAAC,UAAU,CAAC,IAAI,KAAK,kBAAkB;YACnC,UAAU,CAAC,IAAI,KAAK,aAAa;YACjC,UAAU,CAAC,IAAI,KAAK,gBAAgB,CAAC;YACzC,UAAU,CAAC,IAAI,KAAK,WAAW,EACjC,CAAC;YACC,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,IACI,UAAU,CAAC,IAAI,KAAK,cAAc;YAClC,UAAU,CAAC,IAAI,KAAK,WAAW,EACjC,CAAC;YACC,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,IACI,UAAU,CAAC,IAAI,KAAK,YAAY;YAChC,UAAU,CAAC,IAAI,KAAK,WAAW,EACjC,CAAC;YACC,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;AACL,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CACtC,IAAuC,EAChC,EAAE,CAAC,oCAAoC,CAAC,IAAI,CAAC,CAAC"}

package/dist/_internal/type-reference-node.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ * Predicate helpers for narrowing `TSTypeReference` nodes by identifier name.
+ */
+import type { TSESTree } from "@typescript-eslint/utils";
+/**
+ * Checks whether a type node is an identifier-based type reference with a
+ * specific symbol name.
+ *
+ * @param node - Type node candidate.
+ * @param identifierName - Expected referenced identifier name.
+ *
+ * @returns `true` when the node is `TSTypeReference` and the referenced
+ *   `typeName` identifier matches exactly.
+ */
+export declare const isIdentifierTypeReference: (node: Readonly<TSESTree.TypeNode>, identifierName: string) => node is TSESTree.TSTypeReference & {
+    typeName: TSESTree.Identifier;
+};
+//# sourceMappingURL=type-reference-node.d.ts.map

package/dist/_internal/type-reference-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-reference-node.d.ts","sourceRoot":"","sources":["../../src/_internal/type-reference-node.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAClC,MAAM,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,EACjC,gBAAgB,MAAM,KACvB,IAAI,IAAI,QAAQ,CAAC,eAAe,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAA;CAG5B,CAAC"}

package/dist/_internal/type-reference-node.js

@@ -0,0 +1,14 @@
+/**
+ * Checks whether a type node is an identifier-based type reference with a
+ * specific symbol name.
+ *
+ * @param node - Type node candidate.
+ * @param identifierName - Expected referenced identifier name.
+ *
+ * @returns `true` when the node is `TSTypeReference` and the referenced
+ *   `typeName` identifier matches exactly.
+ */
+export const isIdentifierTypeReference = (node, identifierName) => node.type === "TSTypeReference" &&
+    node.typeName.type === "Identifier" &&
+    node.typeName.name === identifierName;
+//# sourceMappingURL=type-reference-node.js.map

package/dist/_internal/type-reference-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-reference-node.js","sourceRoot":"","sources":["../../src/_internal/type-reference-node.ts"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACrC,IAAiC,EACjC,cAAsB,EAC8C,EAAE,CACtE,IAAI,CAAC,IAAI,KAAK,iBAAiB;IAC/B,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;IACnC,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC"}

package/dist/_internal/typed-member-call-rule.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @packageDocumentation
+ * Shared reporting helper for typed ts-extras identifier-member call rules.
+ */
+import type { TSESLint, TSESTree } from "@typescript-eslint/utils";
+import type { UnknownArray } from "type-fest";
+import { type ImportedValueAliasMap } from "./imported-value-symbols.js";
+/** Direct named value imports collection type from shared import helper. */
+type DirectNamedValueImports = ImportedValueAliasMap;
+/** Typed rule context shape for typed member-call rules. */
+type TypedMemberCallRuleContext<MessageId extends string> = Readonly<TSESLint.RuleContext<MessageId, Readonly<UnknownArray>>>;
+/**
+ * Match `<expr>.<memberName>(...)` and report a standardized ts-extras helper
+ * replacement when the receiver expression satisfies a caller-provided type
+ * predicate.
+ */
+export declare const reportTsExtrasTypedMemberCall: <MessageId extends string>({ canAutofix, context, importedName, imports, isMatchingObjectExpression, memberName, messageId, node, reportSuggestion, suggestionMessageId, }: Readonly<{
+    canAutofix?: (node: Readonly<TSESTree.CallExpression>) => boolean;
+    context: TypedMemberCallRuleContext<MessageId>;
+    importedName: string;
+    imports: DirectNamedValueImports;
+    isMatchingObjectExpression: (expression: Readonly<TSESTree.Expression>) => boolean;
+    memberName: string;
+    messageId: MessageId;
+    node: Readonly<TSESTree.CallExpression>;
+    reportSuggestion?: (input: Readonly<{
+        fix: TSESLint.ReportFixFunction;
+        messageId: MessageId;
+        node: Readonly<TSESTree.CallExpression>;
+        suggestionMessageId: MessageId;
+    }>) => void;
+    suggestionMessageId?: MessageId;
+}>) => void;
+export {};
+//# sourceMappingURL=typed-member-call-rule.d.ts.map

package/dist/_internal/typed-member-call-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-member-call-rule.d.ts","sourceRoot":"","sources":["../../src/_internal/typed-member-call-rule.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAEH,KAAK,qBAAqB,EAC7B,MAAM,6BAA6B,CAAC;AAQrC,4EAA4E;AAC5E,KAAK,uBAAuB,GAAG,qBAAqB,CAAC;AAErD,4DAA4D;AAC5D,KAAK,0BAA0B,CAAC,SAAS,SAAS,MAAM,IAAI,QAAQ,CAChE,QAAQ,CAAC,WAAW,CAAC,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC,CAC1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GAAI,SAAS,SAAS,MAAM,EAAE,iJAWrE,QAAQ,CAAC;IACR,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,KAAK,OAAO,CAAC;IAClE,OAAO,EAAE,0BAA0B,CAAC,SAAS,CAAC,CAAC;IAC/C,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,uBAAuB,CAAC;IACjC,0BAA0B,EAAE,CACxB,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,KACxC,OAAO,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;IACxC,gBAAgB,CAAC,EAAE,CACf,KAAK,EAAE,QAAQ,CAAC;QACZ,GAAG,EAAE,QAAQ,CAAC,iBAAiB,CAAC;QAChC,SAAS,EAAE,SAAS,CAAC;QACrB,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QACxC,mBAAmB,EAAE,SAAS,CAAC;KAClC,CAAC,KACD,IAAI,CAAC;IACV,mBAAmB,CAAC,EAAE,SAAS,CAAC;CACnC,CAAC,KAAG,IA+CJ,CAAC"}