ai-deslop 0.2.0 → 0.2.2

package/dist/shared/dictionary-types.js

@@ -0,0 +1,377 @@
+import { createTypeAliasEnvironment, hasVisibleTypeBinding, visibleTypeAlias, } from "./type-alias-resolution.js";
+const BUILT_INS = new Set([
+    "Record",
+    "Readonly",
+    "Partial",
+    "Required",
+    "Pick",
+    "Omit",
+    "PropertyKey",
+    "NonNullable",
+]);
+const TRANSPARENT_WRAPPERS = new Set(["Readonly", "Partial", "Required", "NonNullable"]);
+function declaredStatement(statement) {
+    return statement.type === "ExportNamedDeclaration" ||
+        statement.type === "ExportDefaultDeclaration"
+        ? (statement.declaration ?? null)
+        : statement;
+}
+export function createTypeEnvironment(program, visitorKeys) {
+    const interfaces = new Map();
+    for (const statement of program.body) {
+        const declaration = declaredStatement(statement);
+        if (declaration?.type !== "TSInterfaceDeclaration")
+            continue;
+        const declarations = interfaces.get(declaration.id.name) ?? [];
+        declarations.push(declaration);
+        interfaces.set(declaration.id.name, declarations);
+    }
+    return {
+        interfaces,
+        typeAliases: createTypeAliasEnvironment(program, visitorKeys),
+    };
+}
+function typeReferenceName(type) {
+    return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isBuiltIn(name, use, environment) {
+    return (BUILT_INS.has(name) &&
+        !hasVisibleTypeBinding(name, use, environment.typeAliases));
+}
+function isUnappliedReferenceTo(type, name) {
+    const unwrapped = unwrapTransparentType(type);
+    return (unwrapped.type === "TSTypeReference" &&
+        typeReferenceName(unwrapped) === name &&
+        (unwrapped.typeArguments === null ||
+            unwrapped.typeArguments === undefined ||
+            unwrapped.typeArguments.params.length === 0));
+}
+function unwrapTransparentType(type) {
+    let current = type;
+    while (current.type === "TSParenthesizedType" ||
+        (current.type === "TSTypeOperator" && current.operator === "readonly")) {
+        current = current.typeAnnotation;
+    }
+    return current;
+}
+function isNeverType(type) {
+    return unwrapTransparentType(type).type === "TSNeverKeyword";
+}
+function isEffectivelyEmptyMember(member) {
+    return (member.type === "TSPropertySignature" &&
+        member.optional === true &&
+        member.typeAnnotation !== null &&
+        member.typeAnnotation !== undefined &&
+        isNeverType(member.typeAnnotation.typeAnnotation));
+}
+function isEffectivelyEmptyTypeLiteral(type) {
+    return type.members.length === 0 || type.members.every(isEffectivelyEmptyMember);
+}
+function isEffectivelyEmptyInterface(declarations) {
+    if (declarations.length !== 1)
+        return false;
+    const [type] = declarations;
+    return (type !== undefined &&
+        type.extends.length === 0 &&
+        (type.body.body.length === 0 || type.body.body.every(isEffectivelyEmptyMember)));
+}
+function resolvedSubstitutionArgument(type, base, resolving = new Set()) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type !== "TSTypeReference")
+        return type;
+    const name = typeReferenceName(unwrapped);
+    if (name === null || resolving.has(name))
+        return type;
+    const substitution = base.get(name);
+    if (substitution === undefined)
+        return type;
+    const nextResolving = new Set(resolving);
+    nextResolving.add(name);
+    return resolvedSubstitutionArgument(substitution, base, nextResolving);
+}
+function aliasSubstitution(alias, type, base) {
+    const parameters = alias.typeParameters?.params ?? [];
+    const arguments_ = type.typeArguments?.params ?? [];
+    const next = new Map(base);
+    for (const [index, parameter] of parameters.entries()) {
+        const argument = arguments_[index] ?? parameter.default;
+        if (argument === null || argument === undefined)
+            return null;
+        next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
+    }
+    return next;
+}
+function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSUnknownKeyword")
+        return "unknown";
+    if (unwrapped.type === "TSAnyKeyword")
+        return "any";
+    if (unwrapped.type === "TSObjectKeyword")
+        return "object";
+    if (unwrapped.type === "TSTypeLiteral" && isEffectivelyEmptyTypeLiteral(unwrapped))
+        return "empty-object";
+    if (unwrapped.type === "TSUnionType") {
+        return unwrapped.types.some((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases) !== null)
+            ? "union"
+            : null;
+    }
+    if (unwrapped.type === "TSIntersectionType") {
+        const unsafeMembers = unwrapped.types.map((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases));
+        if (unsafeMembers.includes("any"))
+            return "any";
+        return unsafeMembers.length > 0 && unsafeMembers.every((member) => member !== null)
+            ? unsafeMembers[0]
+            : null;
+    }
+    if (unwrapped.type !== "TSTypeReference")
+        return null;
+    const name = typeReferenceName(unwrapped);
+    if (name === null)
+        return null;
+    if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
+        const wrapped = unwrapped.typeArguments?.params[0];
+        return wrapped === undefined
+            ? null
+            : unsafeDirectValue(wrapped, environment, substitutions, resolvingAliases);
+    }
+    const substitution = substitutions.get(name);
+    if (substitution !== undefined) {
+        return isUnappliedReferenceTo(substitution, name)
+            ? null
+            : unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
+    }
+    const interfaceDeclarations = environment.interfaces.get(name);
+    if (interfaceDeclarations !== undefined) {
+        return isEffectivelyEmptyInterface(interfaceDeclarations) ? "empty-object" : null;
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null || resolvingAliases.has(name))
+        return null;
+    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    if (nextSubstitutions === null)
+        return null;
+    const nextResolving = new Set(resolvingAliases);
+    nextResolving.add(name);
+    return unsafeDirectValue(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function dictionaryValueTypes(type, environment, substitutions, resolvingAliases) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSTypeLiteral") {
+        return unwrapped.members.flatMap((member) => member.type === "TSIndexSignature" && member.typeAnnotation !== null
+            ? [{ type: member.typeAnnotation.typeAnnotation, substitutions }]
+            : []);
+    }
+    if (unwrapped.type === "TSMappedType") {
+        return unwrapped.typeAnnotation === null
+            ? []
+            : [{ type: unwrapped.typeAnnotation, substitutions }];
+    }
+    if (unwrapped.type !== "TSTypeReference")
+        return [];
+    const name = typeReferenceName(unwrapped);
+    if (name === null)
+        return [];
+    const substitution = substitutions.get(name);
+    if (substitution !== undefined) {
+        return isUnappliedReferenceTo(substitution, name)
+            ? []
+            : dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
+    }
+    if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
+        const wrapped = unwrapped.typeArguments?.params[0];
+        return wrapped === undefined
+            ? []
+            : dictionaryValueTypes(wrapped, environment, substitutions, resolvingAliases);
+    }
+    if (name === "Record" && isBuiltIn(name, unwrapped, environment)) {
+        const value = unwrapped.typeArguments?.params[1] ?? null;
+        return value === null ? [] : [{ type: value, substitutions }];
+    }
+    if ((name === "Pick" || name === "Omit") &&
+        isBuiltIn(name, unwrapped, environment)) {
+        const source = unwrapped.typeArguments?.params[0];
+        return source === undefined
+            ? []
+            : dictionaryValueTypes(source, environment, substitutions, resolvingAliases);
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null || resolvingAliases.has(name))
+        return [];
+    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    if (nextSubstitutions === null)
+        return [];
+    const nextResolving = new Set(resolvingAliases);
+    nextResolving.add(name);
+    return dictionaryValueTypes(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+export function classifyUnsafeDictionaryValue(valueType, environment) {
+    const unsafeValue = unsafeDirectValue(valueType, environment, new Map(), new Set());
+    return unsafeValue === null ? null : { kind: "unsafe-dictionary", unsafeValue };
+}
+export function classifyUnsafeDictionary(type, environment) {
+    for (const valueType of dictionaryValueTypes(type, environment, new Map(), new Set())) {
+        const unsafeValue = unsafeDirectValue(valueType.type, environment, valueType.substitutions, new Set());
+        if (unsafeValue !== null)
+            return { kind: "unsafe-dictionary", unsafeValue };
+    }
+    return null;
+}
+export function classifyWideningTarget(type, environment) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSUnknownKeyword")
+        return { kind: "unknown" };
+    if (unwrapped.type === "TSObjectKeyword")
+        return { kind: "object" };
+    if (unwrapped.type === "TSTypeLiteral") {
+        return unwrapped.members.some((member) => member.type === "TSIndexSignature")
+            ? { kind: "open dictionary" }
+            : unwrapped.members.length > 0
+                ? { kind: "anonymous object" }
+                : null;
+    }
+    if (unwrapped.type === "TSMappedType")
+        return { kind: "open dictionary" };
+    if (unwrapped.type !== "TSTypeReference")
+        return null;
+    const name = typeReferenceName(unwrapped);
+    if (name === null)
+        return null;
+    if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
+        const wrapped = unwrapped.typeArguments?.params[0];
+        return wrapped === undefined ? null : classifyWideningTarget(wrapped, environment);
+    }
+    if (name === "Record" && isBuiltIn(name, unwrapped, environment)) {
+        return hasBroadRecordKey(unwrapped, environment, new Map())
+            ? { kind: "open dictionary" }
+            : null;
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null)
+        return null;
+    if ((alias.typeParameters?.params.length ?? 0) > 0) {
+        const substitutions = aliasSubstitution(alias, unwrapped, new Map());
+        const resolved = substitutions === null
+            ? null
+            : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name]));
+        return resolved?.kind === "open dictionary" ? { kind: "generic container" } : null;
+    }
+    const substitutions = aliasSubstitution(alias, unwrapped, new Map());
+    if (substitutions === null)
+        return null;
+    const resolved = classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name]));
+    return resolved;
+}
+function hasBroadRecordKey(type, environment, substitutions) {
+    const key = type.typeArguments?.params[0];
+    return key === undefined || isBroadMappedKey(key, environment, substitutions);
+}
+function isBroadMappedKey(type, environment, substitutions, visitedAliases = new Set()) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSStringKeyword" ||
+        unwrapped.type === "TSNumberKeyword" ||
+        unwrapped.type === "TSSymbolKeyword") {
+        return true;
+    }
+    if (unwrapped.type === "TSUnionType") {
+        return unwrapped.types.some((member) => isBroadMappedKey(member, environment, substitutions, visitedAliases));
+    }
+    if (unwrapped.type !== "TSTypeReference")
+        return false;
+    const name = typeReferenceName(unwrapped);
+    if (name === null)
+        return false;
+    const substitution = substitutions.get(name);
+    if (substitution !== undefined && !isUnappliedReferenceTo(substitution, name)) {
+        return isBroadMappedKey(substitution, environment, substitutions, visitedAliases);
+    }
+    if (name === "PropertyKey" && isBuiltIn(name, unwrapped, environment))
+        return true;
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null ||
+        (alias.typeParameters?.params.length ?? 0) > 0 ||
+        visitedAliases.has(name)) {
+        return false;
+    }
+    const nextVisited = new Set(visitedAliases);
+    nextVisited.add(name);
+    return isBroadMappedKey(alias.typeAnnotation, environment, substitutions, nextVisited);
+}
+function classifyAliasBroadTarget(type, environment, substitutions, resolvingAliases) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSUnknownKeyword")
+        return { kind: "unknown" };
+    if (unwrapped.type === "TSObjectKeyword")
+        return { kind: "object" };
+    if (unwrapped.type === "TSTypeLiteral") {
+        return unwrapped.members.some((member) => member.type === "TSIndexSignature")
+            ? { kind: "open dictionary" }
+            : null;
+    }
+    if (unwrapped.type === "TSMappedType") {
+        return isBroadMappedKey(unwrapped.constraint, environment, substitutions)
+            ? { kind: "open dictionary" }
+            : null;
+    }
+    if (unwrapped.type !== "TSTypeReference")
+        return null;
+    const name = typeReferenceName(unwrapped);
+    if (name === null)
+        return null;
+    const substitution = substitutions.get(name);
+    if (substitution !== undefined) {
+        return isUnappliedReferenceTo(substitution, name)
+            ? null
+            : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
+    }
+    if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
+        const wrapped = unwrapped.typeArguments?.params[0];
+        return wrapped === undefined
+            ? null
+            : classifyAliasBroadTarget(wrapped, environment, substitutions, resolvingAliases);
+    }
+    if (name === "Record" && isBuiltIn(name, unwrapped, environment)) {
+        return hasBroadRecordKey(unwrapped, environment, substitutions)
+            ? { kind: "open dictionary" }
+            : null;
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null || resolvingAliases.has(name))
+        return null;
+    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    if (nextSubstitutions === null)
+        return null;
+    const nextResolving = new Set(resolvingAliases);
+    nextResolving.add(name);
+    return classifyAliasBroadTarget(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+export function isPopulatedObjectExpression(expression) {
+    let current = expression;
+    while (current.type === "ParenthesizedExpression" ||
+        current.type === "TSAsExpression" ||
+        current.type === "TSTypeAssertion" ||
+        current.type === "TSNonNullExpression") {
+        current = current.expression;
+    }
+    return current.type === "ObjectExpression" && current.properties.length > 0;
+}
+export function isKnownEvidenceExpression(expression) {
+    let current = expression;
+    while (current.type === "ParenthesizedExpression" ||
+        current.type === "TSAsExpression" ||
+        current.type === "TSTypeAssertion" ||
+        current.type === "TSNonNullExpression" ||
+        current.type === "TSSatisfiesExpression") {
+        current = current.expression;
+    }
+    if (current.type === "ObjectExpression")
+        return true;
+    return (current.type === "ArrayExpression" ||
+        current.type === "ArrowFunctionExpression" ||
+        current.type === "ClassExpression" ||
+        current.type === "FunctionExpression" ||
+        current.type === "NewExpression" ||
+        current.type === "Literal" ||
+        current.type === "TemplateLiteral" ||
+        current.type === "UnaryExpression");
+}

package/dist/shared/function-parameters.d.ts

@@ -0,0 +1,8 @@
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+export type FunctionParameter = ESTree.ParamPattern;
+/** Return whether a type is or contains TypeScript's absorbing unknown top type. */
+export declare function containsUnknownType(type: ESTree.TSType): boolean;
+/** Return the TypeScript annotation attached to a function parameter or its wrapped binding. */
+export declare function functionParameterTypeAnnotation(parameter: FunctionParameter): ESTree.TSTypeAnnotation | null | undefined;
+/** Return only a function parameter's local binding, excluding its annotation and default value. */
+export declare function functionParameterBindingName(parameter: FunctionParameter, sourceCode: SourceCode): string;

package/dist/shared/function-parameters.js

@@ -0,0 +1,40 @@
+/** Return whether a type is or contains TypeScript's absorbing unknown top type. */
+export function containsUnknownType(type) {
+    if (type.type === "TSUnknownKeyword")
+        return true;
+    if (type.type === "TSParenthesizedType")
+        return containsUnknownType(type.typeAnnotation);
+    return type.type === "TSUnionType" && type.types.some(containsUnknownType);
+}
+/** Return the TypeScript annotation attached to a function parameter or its wrapped binding. */
+export function functionParameterTypeAnnotation(parameter) {
+    if (parameter.type === "TSParameterProperty") {
+        return functionParameterTypeAnnotation(parameter.parameter);
+    }
+    if (parameter.type === "RestElement") {
+        return parameter.typeAnnotation ?? functionParameterTypeAnnotation(parameter.argument);
+    }
+    if (parameter.type === "AssignmentPattern") {
+        return parameter.typeAnnotation ?? functionParameterTypeAnnotation(parameter.left);
+    }
+    return parameter.typeAnnotation;
+}
+/** Return only a function parameter's local binding, excluding its annotation and default value. */
+export function functionParameterBindingName(parameter, sourceCode) {
+    if (parameter.type === "TSParameterProperty") {
+        return functionParameterBindingName(parameter.parameter, sourceCode);
+    }
+    if (parameter.type === "AssignmentPattern") {
+        return functionParameterBindingName(parameter.left, sourceCode);
+    }
+    if (parameter.type === "RestElement") {
+        return functionParameterBindingName(parameter.argument, sourceCode);
+    }
+    if (parameter.type === "Identifier")
+        return parameter.name;
+    const sourceText = sourceCode.getText(parameter);
+    const annotationStart = parameter.typeAnnotation?.start;
+    return annotationStart === undefined
+        ? sourceText
+        : sourceText.slice(0, annotationStart - parameter.start).trimEnd();
+}

package/dist/shared/lexical-type-parameters.d.ts

@@ -0,0 +1,5 @@
+import type { ESTree } from "@oxlint/plugins";
+type VisitorKeys = Readonly<Record<string, readonly string[]>>;
+/** Collect type binders that are in scope at a node and can shadow module aliases. */
+export declare function lexicalTypeParameterNames(node: ESTree.Node, visitorKeys: VisitorKeys): ReadonlySet<string>;
+export {};

package/dist/shared/lexical-type-parameters.js

@@ -0,0 +1,47 @@
+function isNode(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "type" in value &&
+        typeof value.type === "string");
+}
+function collectInferTypeParameterNames(node, visitorKeys, names) {
+    if (node.type === "TSInferType")
+        names.add(node.typeParameter.name.name);
+    const record = node;
+    for (const key of visitorKeys[node.type] ?? []) {
+        const value = record[key];
+        if (isNode(value)) {
+            collectInferTypeParameterNames(value, visitorKeys, names);
+            continue;
+        }
+        if (!Array.isArray(value))
+            continue;
+        for (const child of value) {
+            if (isNode(child))
+                collectInferTypeParameterNames(child, visitorKeys, names);
+        }
+    }
+}
+/** Collect type binders that are in scope at a node and can shadow module aliases. */
+export function lexicalTypeParameterNames(node, visitorKeys) {
+    const names = new Set();
+    let descendant = node;
+    let current = node;
+    while (current !== null && current.type !== "Program") {
+        if ("typeParameters" in current) {
+            for (const parameter of current.typeParameters?.params ?? []) {
+                names.add(parameter.name.name);
+            }
+        }
+        if (current.type === "TSMappedType" &&
+            (descendant === current.nameType || descendant === current.typeAnnotation)) {
+            names.add(current.key.name);
+        }
+        if (current.type === "TSConditionalType" && descendant === current.trueType) {
+            collectInferTypeParameterNames(current.extendsType, visitorKeys, names);
+        }
+        descendant = current;
+        current = current.parent;
+    }
+    return names;
+}

package/dist/shared/reflect-method.d.ts

@@ -0,0 +1,3 @@
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+/** Reports whether a call target names one method on the global Reflect object. */
+export declare function isGlobalReflectMethodCall(sourceCode: SourceCode, callee: ESTree.Expression, methodName: string): boolean;

package/dist/shared/reflect-method.js

@@ -0,0 +1,20 @@
+import { resolveVariable } from "./scope.js";
+function isGlobalReflect(sourceCode, expression) {
+    if (expression.type !== "Identifier" || expression.name !== "Reflect")
+        return false;
+    if (sourceCode.isGlobalReference(expression))
+        return true;
+    const variable = resolveVariable(sourceCode, expression);
+    return variable === null || variable.defs.length === 0;
+}
+/** Reports whether a call target names one method on the global Reflect object. */
+export function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
+    if (!("property" in callee) || !("object" in callee) || !("computed" in callee))
+        return false;
+    if (!isGlobalReflect(sourceCode, callee.object))
+        return false;
+    const property = callee.property;
+    return callee.computed
+        ? property.type === "Literal" && property.value === methodName
+        : property.type === "Identifier" && property.name === methodName;
+}

package/dist/shared/scope.d.ts

@@ -0,0 +1,3 @@
+import type { ESTree, SourceCode, Variable } from "@oxlint/plugins";
+/** Resolve an identifier to its binding by walking lexical scopes upward. */
+export declare function resolveVariable(sourceCode: SourceCode, identifier: ESTree.IdentifierReference): Variable | null;

package/dist/shared/scope.js

@@ -0,0 +1,11 @@
+/** Resolve an identifier to its binding by walking lexical scopes upward. */
+export function resolveVariable(sourceCode, identifier) {
+    let scope = sourceCode.getScope(identifier);
+    while (scope !== null) {
+        const variable = scope.set.get(identifier.name);
+        if (variable !== undefined)
+            return variable;
+        scope = scope.upper;
+    }
+    return null;
+}

package/dist/shared/type-alias-resolution.d.ts

@@ -0,0 +1,23 @@
+import type { ESTree } from "@oxlint/plugins";
+type VisitorKeys = Readonly<Record<string, readonly string[]>>;
+type TypeScope = ESTree.Node;
+type TypeBinding = {
+    readonly alias: ESTree.TSTypeAliasDeclaration | null;
+    readonly name: string;
+    readonly scope: TypeScope;
+};
+export type TypeAliasEnvironment = {
+    readonly aliases: readonly ESTree.TSTypeAliasDeclaration[];
+    readonly bindingsByName: ReadonlyMap<string, readonly TypeBinding[]>;
+    readonly visitorKeys: VisitorKeys;
+};
+export type ResolvedTypeMatcher = (type: ESTree.TSType, matches: (child: ESTree.TSType) => boolean) => boolean;
+/** Collect every lexical type alias and competing type binding in a program. */
+export declare function createTypeAliasEnvironment(program: ESTree.Program, visitorKeys: VisitorKeys): TypeAliasEnvironment;
+/** Resolve the nearest visible alias with this name, respecting lexical shadowing. */
+export declare function visibleTypeAlias(name: string, use: ESTree.Node, environment: TypeAliasEnvironment): ESTree.TSTypeAliasDeclaration | null;
+/** Return whether a local declaration shadows a built-in type at this use. */
+export declare function hasVisibleTypeBinding(name: string, use: ESTree.Node, environment: TypeAliasEnvironment): boolean;
+/** Match a type after resolving visible aliases and substituting their type parameters. */
+export declare function resolvedTypeMatches(type: ESTree.TSType, environment: TypeAliasEnvironment, matcher: ResolvedTypeMatcher): boolean;
+export {};