@darraghor/eslint-plugin-nestjs-typed 6.0.0-rc.7 → 6.0.0-rc.8

package/dist/configs/base.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    parser: string;
+    parserOptions: {
+        sourceType: "module";
+    };
+    plugins: string[];
+};
+export = _default;

package/dist/configs/index.d.ts

@@ -0,0 +1,11 @@
+declare const allConfigs: {
+    recommended: {
+        extends: string[];
+        rules: Partial<import("eslint").Linter.RulesRecord>;
+    };
+    "no-swagger": {
+        extends: string[];
+        rules: Partial<import("eslint").Linter.RulesRecord>;
+    };
+};
+export default allConfigs;

package/dist/configs/noSwagger.d.ts

@@ -0,0 +1,6 @@
+import { Linter } from "eslint";
+declare const _default: {
+    extends: string[];
+    rules: Partial<Linter.RulesRecord>;
+};
+export = _default;

package/dist/configs/recommended.d.ts

@@ -0,0 +1,6 @@
+import { Linter } from "eslint";
+declare const _default: {
+    extends: string[];
+    rules: Partial<Linter.RulesRecord>;
+};
+export = _default;

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import type { FlatConfig } from "@typescript-eslint/utils/ts-eslint";
+import { TSESLint } from "@typescript-eslint/utils";
+export declare const parser: TSESLint.FlatConfig.Parser;
+export declare const plugin: TSESLint.FlatConfig.Plugin;
+declare const classicPlugin: {
+    configs: {
+        recommended: {
+            extends: string[];
+            rules: Partial<import("eslint").Linter.RulesRecord>;
+        };
+        "no-swagger": {
+            extends: string[];
+            rules: Partial<import("eslint").Linter.RulesRecord>;
+        };
+    };
+    rules: {
+        "all-properties-have-explicit-defined": TSESLint.RuleModule<"missing-is-defined-decorator" | "missing-is-optional-decorator" | "conflicting-defined-decorators-defined-optional" | "conflicting-defined-decorators-defined-validate-if" | "conflicting-defined-decorators-optional-validate-if" | "conflicting-defined-decorators-all", [], unknown, TSESLint.RuleListener>;
+        "api-property-matches-property-optionality": TSESLint.RuleModule<"shouldUseOptionalDecorator" | "shouldUseRequiredDecorator", [], unknown, TSESLint.RuleListener>;
+        "injectable-should-be-provided": TSESLint.RuleModule<"injectableInModule" | "controllersInModule", [{
+            src: string[];
+            filterFromPaths: string[];
+        }], unknown, TSESLint.RuleListener>;
+        "no-duplicate-decorators": TSESLint.RuleModule<"noDuplicateDecorators", import("./rules/noDuplicateDecorators/noDuplicateDecorators").NoDuplicateDecoratorsOptions, unknown, TSESLint.RuleListener>;
+        "provided-injected-should-match-factory-parameters": TSESLint.RuleModule<"mainMessage", [], unknown, TSESLint.RuleListener>;
+        "controllers-should-supply-api-tags": TSESLint.RuleModule<"shouldUseApiTagDecorator", [], unknown, TSESLint.RuleListener>;
+        "api-method-should-specify-api-response": TSESLint.RuleModule<"shouldSpecifyApiResponse", [], unknown, TSESLint.RuleListener>;
+        "api-method-should-specify-api-operation": TSESLint.RuleModule<"shouldSpecifyApiOperation", [], unknown, TSESLint.RuleListener>;
+        "api-enum-property-best-practices": TSESLint.RuleModule<"needsEnumNameAdded" | "needsTypeRemoved" | "enumNameShouldMatchType", [], unknown, TSESLint.RuleListener>;
+        "api-property-returning-array-should-set-array": TSESLint.RuleModule<"shouldSetArrayPropertyTrue" | "shouldSetArrayPropertyFalse", [], unknown, TSESLint.RuleListener>;
+        "should-specify-forbid-unknown-values": TSESLint.RuleModule<"shouldSpecifyForbidUnknownValues", [], unknown, TSESLint.RuleListener>;
+        "param-decorator-name-matches-route-param": TSESLint.RuleModule<"paramIdentifierDoesntNeedColon" | "paramIdentifierShouldMatch", [], unknown, TSESLint.RuleListener>;
+        "validated-non-primitive-property-needs-type-decorator": TSESLint.RuleModule<"shouldUseTypeDecorator" | "autofixWithTypeDecorator", import("./rules/validateNonPrimitiveNeedsTypeDecorator/validateNonPrimitiveNeedsDecorators").ValidateNonPrimitivePropertyTypeDecoratorOptions, unknown, TSESLint.RuleListener>;
+        "validate-nested-of-array-should-set-each": TSESLint.RuleModule<"shouldSetEachPropertyTrue" | "shouldSetEachPropertyFalse", [], unknown, TSESLint.RuleListener>;
+        "all-properties-are-whitelisted": TSESLint.RuleModule<"missing-property-decorator", [], unknown, TSESLint.RuleListener>;
+        "api-methods-should-be-guarded": TSESLint.RuleModule<"apiMethodsShouldBeGuarded", [], unknown, TSESLint.RuleListener>;
+        "sort-module-metadata-arrays": TSESLint.RuleModule<"moduleMetadataArraysAreSorted", import("./rules/sortModuleMetadataArrays/sortModuleMetadataArrays").RuleOptions, unknown, TSESLint.RuleListener>;
+    };
+    meta: {
+        name: string;
+        version: string;
+    };
+};
+export declare function flatBaseConfig(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.Config;
+export declare function flatRecommendedConfig(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray;
+export declare function flatNoSwaggerConfig(): FlatConfig.ConfigArray;
+export { classicPlugin };
+export type ConfigArray = TSESLint.FlatConfig.ConfigArray;
+declare const _default: {
+    configs: {
+        flatRecommended: ConfigArray;
+        flatNoSwagger: ConfigArray;
+    };
+};
+export default _default;

package/dist/rules/allPropertiesAreWhitelisted/allPropertiesAreWhitelisted.d.ts

@@ -0,0 +1,2 @@
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missing-property-decorator", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/allPropertiesHaveExplicitDefined/allPropertiesHaveExplicitDefined.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+declare const rule: ESLintUtils.RuleModule<"missing-is-defined-decorator" | "missing-is-optional-decorator" | "conflicting-defined-decorators-defined-optional" | "conflicting-defined-decorators-defined-validate-if" | "conflicting-defined-decorators-optional-validate-if" | "conflicting-defined-decorators-all", [], unknown, ESLintUtils.RuleListener>;
+export default rule;

package/dist/rules/apiEnumPropertyBestPractices/apiEnumPropertyBestPractices.d.ts

@@ -0,0 +1,6 @@
+import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
+import { EnumTestResultModel } from "./enumTestResultModel";
+export declare const hasEnumSpecifiedCorrectly: (node: TSESTree.Node, isEnumType: boolean) => EnumTestResultModel;
+export declare const needsEnumNameMatchingEnumType: (enumNameProperty: TSESTree.Property, enumProperty: TSESTree.Property) => boolean;
+declare const rule: ESLintUtils.RuleModule<"needsEnumNameAdded" | "needsTypeRemoved" | "enumNameShouldMatchType", [], unknown, ESLintUtils.RuleListener>;
+export default rule;

package/dist/rules/apiEnumPropertyBestPractices/enumTestResultModel.d.ts

@@ -0,0 +1,7 @@
+export declare class EnumTestResultModel {
+    constructor(init: EnumTestResultModel);
+    needsEnumAdded: boolean;
+    needsTypeRemoved: boolean;
+    needsEnumNameAdded: boolean;
+    needsEnumNameToMatchEnumType: boolean;
+}

package/dist/rules/apiMethodsShouldBeGuarded/apiMethodsShouldBeGuarded.d.ts

@@ -0,0 +1,4 @@
+import { TSESTree } from "@typescript-eslint/utils";
+export declare const apiMethodsShouldBeGuarded: (node: TSESTree.MethodDefinition) => boolean;
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"apiMethodsShouldBeGuarded", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/apiMethodsShouldSpecifyApiOperation/apiMethodsShouldSpecifyApiOperation.d.ts

@@ -0,0 +1,4 @@
+import { TSESTree } from "@typescript-eslint/utils";
+export declare const shouldUseApiResponseDecorator: (node: TSESTree.MethodDefinition) => boolean;
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldSpecifyApiOperation", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/apiMethodsShouldSpecifyApiResponse/apiMethodsShouldSpecifyApiResponse.d.ts

@@ -0,0 +1,4 @@
+import { TSESTree } from "@typescript-eslint/utils";
+export declare const shouldUseApiResponseDecorator: (node: TSESTree.MethodDefinition) => boolean;
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldSpecifyApiResponse", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/apiPropertyMatchesPropertyOptionality/apiPropertyMatchesPropertyOptionality.d.ts

@@ -0,0 +1,5 @@
+import { TSESTree } from "@typescript-eslint/utils";
+export declare const shouldUseRequiredDecorator: (node: TSESTree.PropertyDefinition) => boolean;
+export declare const shouldUseOptionalDecorator: (node: TSESTree.PropertyDefinition) => boolean;
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldUseOptionalDecorator" | "shouldUseRequiredDecorator", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/apiPropertyReturningArrayShouldSetArray/apiPropertyReturningArrayShouldSetArray.d.ts

@@ -0,0 +1,5 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import ArraySetResultModel from "./arraySetResultModel";
+export declare const shouldSetArrayProperty: (node: TSESTree.PropertyDefinition) => ArraySetResultModel;
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldSetArrayPropertyTrue" | "shouldSetArrayPropertyFalse", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/apiPropertyReturningArrayShouldSetArray/arraySetResultModel.d.ts

@@ -0,0 +1,5 @@
+export default class ArraySetResultModel {
+    isArrayShouldBeSetTrue: boolean;
+    isArrayShouldBeSetFalse: boolean;
+    constructor(isArrayShouldBeSetTrue: boolean, isArrayShouldBeSetFalse: boolean);
+}

package/dist/rules/controllerDecoratedHasApiTags/controllerDecoratedHasApiTags.d.ts

@@ -0,0 +1,4 @@
+import { TSESTree } from "@typescript-eslint/utils";
+export declare const shouldUseApiTagDecorator: (node: TSESTree.ClassDeclaration) => boolean;
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldUseApiTagDecorator", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/index.d.ts

@@ -0,0 +1,23 @@
+declare const allRules: {
+    "all-properties-have-explicit-defined": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missing-is-defined-decorator" | "missing-is-optional-decorator" | "conflicting-defined-decorators-defined-optional" | "conflicting-defined-decorators-defined-validate-if" | "conflicting-defined-decorators-optional-validate-if" | "conflicting-defined-decorators-all", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "api-property-matches-property-optionality": import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldUseOptionalDecorator" | "shouldUseRequiredDecorator", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "injectable-should-be-provided": import("@typescript-eslint/utils/ts-eslint").RuleModule<"injectableInModule" | "controllersInModule", [{
+        src: string[];
+        filterFromPaths: string[];
+    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-duplicate-decorators": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noDuplicateDecorators", import("./noDuplicateDecorators/noDuplicateDecorators").NoDuplicateDecoratorsOptions, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "provided-injected-should-match-factory-parameters": import("@typescript-eslint/utils/ts-eslint").RuleModule<"mainMessage", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "controllers-should-supply-api-tags": import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldUseApiTagDecorator", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "api-method-should-specify-api-response": import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldSpecifyApiResponse", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "api-method-should-specify-api-operation": import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldSpecifyApiOperation", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "api-enum-property-best-practices": import("@typescript-eslint/utils/ts-eslint").RuleModule<"needsEnumNameAdded" | "needsTypeRemoved" | "enumNameShouldMatchType", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "api-property-returning-array-should-set-array": import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldSetArrayPropertyTrue" | "shouldSetArrayPropertyFalse", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "should-specify-forbid-unknown-values": import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldSpecifyForbidUnknownValues", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "param-decorator-name-matches-route-param": import("@typescript-eslint/utils/ts-eslint").RuleModule<"paramIdentifierDoesntNeedColon" | "paramIdentifierShouldMatch", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "validated-non-primitive-property-needs-type-decorator": import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldUseTypeDecorator" | "autofixWithTypeDecorator", import("./validateNonPrimitiveNeedsTypeDecorator/validateNonPrimitiveNeedsDecorators").ValidateNonPrimitivePropertyTypeDecoratorOptions, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "validate-nested-of-array-should-set-each": import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldSetEachPropertyTrue" | "shouldSetEachPropertyFalse", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "all-properties-are-whitelisted": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missing-property-decorator", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "api-methods-should-be-guarded": import("@typescript-eslint/utils/ts-eslint").RuleModule<"apiMethodsShouldBeGuarded", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "sort-module-metadata-arrays": import("@typescript-eslint/utils/ts-eslint").RuleModule<"moduleMetadataArraysAreSorted", import("./sortModuleMetadataArrays/sortModuleMetadataArrays").RuleOptions, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+};
+export default allRules;

package/dist/rules/injectablesShouldBeProvided/injectableShouldBeProvided.d.ts

@@ -0,0 +1,9 @@
+import { TSESLint } from "@typescript-eslint/utils";
+type Options = [
+    {
+        src: string[];
+        filterFromPaths: string[];
+    }
+];
+declare const rule: TSESLint.RuleModule<"injectableInModule" | "controllersInModule", Options, unknown, TSESLint.RuleListener>;
+export default rule;

package/dist/rules/noDuplicateDecorators/noDuplicateDecorators.d.ts

@@ -0,0 +1,9 @@
+export type NoDuplicateDecoratorsOptions = [
+    {
+        customList: string[];
+    }
+];
+export declare const shouldTrigger: () => boolean;
+export declare const standardDecoratorsToValidate: string[];
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noDuplicateDecorators", NoDuplicateDecoratorsOptions, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/paramDecoratorNameMatchesRouteParam/paramDecoratorNameMatchesRouteParam.d.ts

@@ -0,0 +1,21 @@
+import { TSESTree } from "@typescript-eslint/utils";
+interface ResultModel {
+    hasColonInName: boolean;
+    paramNameNotMatchedInPath: boolean;
+}
+export declare const parsePathParts: (decorator: TSESTree.Decorator) => string[];
+/**
+ * nestjs allows for paths with _+?()*
+ * this rule doesn't support parsing those so we'll just pass
+ */
+export declare const hasPathPartsAnyRegexParams: (pathPartsToCheck: string[]) => boolean;
+/**
+ * Checks if there is a matching path part for the paramName
+ * @param paramName
+ * @param pathPartsToCheck
+ * @returns
+ */
+export declare const isParameterNameIncludedInAPathPart: (paramName: string, pathPartsToCheck: string[]) => boolean;
+export declare const shouldTrigger: (decorator: TSESTree.Decorator) => ResultModel;
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"paramIdentifierDoesntNeedColon" | "paramIdentifierShouldMatch", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/paramDecoratorNameMatchesRouteParam/rule.testData.d.ts

@@ -0,0 +1,10 @@
+export declare const pathPartTestCases: {
+    moduleCode: string;
+    paths: string[];
+    message: string;
+}[];
+export declare const responseParsingTestCases: {
+    pathToCheck: string;
+    paths: string[];
+    shouldResult: boolean;
+}[];

package/dist/rules/providerInjectedShouldMatchFactory/ProviderInjectedShouldMatchFactory.d.ts

@@ -0,0 +1,4 @@
+import { TSESTree } from "@typescript-eslint/utils";
+export declare const hasMismatchedInjected: (node: TSESTree.VariableDeclarator) => boolean;
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"mainMessage", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/shouldSpecifyForbidUnknownValues/shouldSpecifyForbidUnknownValuesRule.d.ts

@@ -0,0 +1,7 @@
+import { TSESTree } from "@typescript-eslint/utils";
+export declare const isValidationPipeNewExpression: (node: TSESTree.Node) => boolean;
+export declare const checkObjectExpression: (os: TSESTree.ObjectExpression) => boolean;
+export declare const shouldTriggerNewExpressionHasProperty: (node: TSESTree.Node) => boolean;
+export declare const shouldTriggerForVariableDeclaratorExpression: (node: TSESTree.VariableDeclarator) => boolean;
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldSpecifyForbidUnknownValues", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/sortModuleMetadataArrays/sortModuleMetadataArrays.d.ts

@@ -0,0 +1,11 @@
+import { TSESTree } from "@typescript-eslint/utils";
+export type RuleOptions = [
+    {
+        locale?: string;
+    }
+];
+export type ValidModuleNodeTypes = TSESTree.Identifier | TSESTree.CallExpression;
+export declare const isValidModuleMetaPropertyType: (node: TSESTree.Expression | TSESTree.SpreadElement | null) => node is ValidModuleNodeTypes;
+export declare const getRelevantNodeName: (node: TSESTree.Node) => string;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moduleMetadataArraysAreSorted", RuleOptions, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;

package/dist/rules/validateNestedOfArrayShouldSetEach/arraySetResultModel.d.ts

@@ -0,0 +1,5 @@
+export default class ArraySetResultModel {
+    isArrayShouldBeSetTrue: boolean;
+    isArrayShouldBeSetFalse: boolean;
+    constructor(isArrayShouldBeSetTrue: boolean, isArrayShouldBeSetFalse: boolean);
+}

package/dist/rules/validateNestedOfArrayShouldSetEach/validateNestedOfArrayShouldSetEach.d.ts

@@ -0,0 +1,5 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import ArraySetResultModel from "./arraySetResultModel";
+export declare const shouldSetArrayProperty: (node: TSESTree.PropertyDefinition) => ArraySetResultModel;
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldSetEachPropertyTrue" | "shouldSetEachPropertyFalse", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/validateNonPrimitiveNeedsTypeDecorator/validateNonPrimitiveNeedsDecorators.d.ts

@@ -0,0 +1,10 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export type ValidateNonPrimitivePropertyTypeDecoratorOptions = [
+    {
+        additionalTypeDecorators: string[];
+        additionalCustomValidatorDecorators: string[];
+    }
+];
+export declare const shouldTrigger: () => boolean;
+declare const rule: ESLintUtils.RuleModule<"shouldUseTypeDecorator" | "autofixWithTypeDecorator", ValidateNonPrimitivePropertyTypeDecoratorOptions, unknown, ESLintUtils.RuleListener>;
+export default rule;

package/dist/testing/fixtureSetup.d.ts

@@ -0,0 +1 @@
+export declare function getFixturesRootDirectory(): string;

package/dist/testing/preRun.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/dist/utils/ast.d.ts

@@ -0,0 +1,2 @@
+import { TSESTree } from "@typescript-eslint/types";
+export declare function getPropertiesDefinitions(classDeclaration: TSESTree.ClassDeclaration): TSESTree.PropertyDefinition[];

package/dist/utils/createRule.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener>;

package/dist/utils/files/customFileEnumeratorWrapper.d.ts

@@ -0,0 +1,8 @@
+interface FilePath {
+    ignored: boolean;
+    filename: string;
+}
+export declare class FileEnumerator {
+    static enumerateFiles(sourceGlobs: string[], extensions: string[], filterFromPaths: string[]): FilePath[];
+}
+export default FileEnumerator;

package/dist/utils/files/isFilteredPath.d.ts

@@ -0,0 +1,4 @@
+declare class IsFilteredPath {
+    static test: (path: string | undefined, filteredStrings: string[] | undefined) => boolean;
+}
+export default IsFilteredPath;

package/dist/utils/nestModules/models/NestProvidedInjectablesMap.d.ts

@@ -0,0 +1,5 @@
+export declare class NestProvidedInjectablesMap {
+    controllers: Set<string>;
+    providers: Set<string>;
+    constructor(controllers: Set<string>, providers: Set<string>);
+}

package/dist/utils/nestModules/nestModuleAstParser.d.ts

@@ -0,0 +1,7 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import { NestProvidedInjectablesMap } from "./models/NestProvidedInjectablesMap";
+export declare const nestModuleAstParser: {
+    findNestModuleClass(ast: TSESTree.Program): TSESTree.ClassDeclaration | null;
+    mapNestModuleDecorator(n: TSESTree.ClassDeclaration, path: string): [string, NestProvidedInjectablesMap] | null;
+    mapModuleDecoratorOptionProperty(moduleDecorator: TSESTree.Decorator, propertyName: string): Set<string>;
+};

package/dist/utils/nestModules/nestProvidedInjectableMapper.d.ts

@@ -0,0 +1,14 @@
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+import { NestProvidedInjectablesMap } from "./models/NestProvidedInjectablesMap";
+declare const NestProvidedInjectableMapper: {
+    detectDirectoryToScanForFiles(sourceGlob: string | string[] | undefined, currentWorkingDirectory: string): string[];
+    parseFileList(files: {
+        ignored: boolean;
+        filename: string;
+    }[], context: Readonly<TSESLint.RuleContext<never, any>>): Map<string, NestProvidedInjectablesMap>;
+    notEmpty<TValue>(value: TValue | null): value is TValue;
+    readFileContents(path: string): string;
+    isNestInjectableThatIsNeverProvided(node: TSESTree.ClassDeclaration): boolean;
+    mapAllProvidedInjectables(ast: TSESTree.Program, path: string): [string, NestProvidedInjectablesMap] | null;
+};
+export default NestProvidedInjectableMapper;

package/dist/utils/nestModules/nestProvidedInjectableMapper.testData.d.ts

@@ -0,0 +1,7 @@
+import { NestProvidedInjectablesMap } from "./models/NestProvidedInjectablesMap";
+export declare const fakeFilePath = "fake/path.ts";
+export declare const fakeContext: any;
+export declare const moduleMappingTestData: {
+    moduleCode: string;
+    expectedMapping: (string | NestProvidedInjectablesMap)[];
+}[];

package/dist/utils/nestModules/nestProviderAstParser.d.ts

@@ -0,0 +1,7 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import { NestProvidedInjectablesMap } from "./models/NestProvidedInjectablesMap";
+export declare const nestProviderAstParser: {
+    mapNestProviderObject(n: TSESTree.Property, path: string): [string, NestProvidedInjectablesMap] | null;
+    findProvideProperty(providerDeclaration: TSESTree.VariableDeclarator | undefined, propertyName: string): TSESTree.Property | null;
+    findNestProviderVariableDeclaration(ast: TSESTree.Program): TSESTree.VariableDeclarator | undefined;
+};

package/dist/utils/typedTokenHelpers.d.ts

@@ -0,0 +1,59 @@
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+import { ParserServices } from "@typescript-eslint/parser";
+import ts from "typescript";
+export declare const typedTokenHelpers: {
+    decoratorsThatCouldMeanTheDevIsValidatingAnArray: string[];
+    isTypeArrayTypeOrUnionOfArrayTypes(node: TSESTree.Node, parserService: ParserServices, checker: ts.TypeChecker): boolean;
+    getNodeType(node: TSESTree.Node, parserService: ParserServices, checker: ts.TypeChecker): ts.Type;
+    expressionNodeIsArrayType(node: TSESTree.Expression, parserService: ParserServices, checker: ts.TypeChecker): boolean;
+    getPropertyValueEqualsExpected(firstArgument: TSESTree.ObjectExpression, propertyName: string, expectedValue: string | number | bigint | boolean | RegExp | null): boolean;
+    getConstrainedTypeAtLocation(checker: ts.TypeChecker, node: ts.Node): ts.Type;
+    nodeHasDecoratorsNamed(n: TSESTree.ClassDeclaration | TSESTree.PropertyDefinition | TSESTree.MethodDefinition, decoratorNames: string[]): boolean;
+    getDecoratorsNamed(n: TSESTree.ClassDeclaration | TSESTree.PropertyDefinition | TSESTree.MethodDefinition, decoratorNames: string[]): TSESTree.Decorator[];
+    parseStringToAst(code: string, path: string, context: Readonly<TSESLint.RuleContext<never, never[]>>): TSESTree.Program;
+    isEnumType(type: ts.Type): boolean;
+    isOptionalPropertyValue(node: TSESTree.PropertyDefinition): boolean;
+    /**
+     * Checks if an import is an import of the given decorator name
+     * @param imp
+     * @param decoratorName
+     */
+    importIsDecorator(imp: TSESTree.ImportDeclaration, decoratorName: string): boolean;
+    /**
+     * Checks if decorator is in imports of a node
+     * @param imports
+     * @param decorator
+     */
+    decoratorIsImportedFromClassValidator(imports: TSESTree.ImportDeclaration[], decorator: TSESTree.Decorator): boolean;
+    /**
+     * Checks whether a decorator is a class validator decorator
+     * @param program The root program node
+     * @param decorator The decorator node
+     */
+    decoratorIsClassValidatorDecorator(program: TSESTree.Program | null, decorator: TSESTree.Decorator): boolean;
+    /**
+     * Gets the root program of a node
+     * @param node
+     */
+    getRootProgram(node: TSESTree.BaseNode): TSESTree.Program | null;
+    /**
+     * Gets all the decorators actually imported from class-validator lib or decorators that were included in the additionalCustomValidatorDecorators options
+     * @param node PropertyDefinition node
+     */
+    getValidationDecorators(node: TSESTree.PropertyDefinition, additionalCustomValidatorDecorators?: string[]): TSESTree.Decorator[];
+    /**
+     * Checks if the decorator is the IsEnum decorator
+     * @param decorator
+     */
+    decoratorIsIsEnum(decorator: TSESTree.Decorator): boolean;
+    /** Checks if the decorator is the IsObject decorator
+     * @param decorator
+     */
+    decoratorIsIsObject(decorator: TSESTree.Decorator): boolean;
+    /**
+     * Gets the name of a decorator
+     * Returns null if no name is found
+     * @param decorator
+     */
+    getDecoratorName(decorator: TSESTree.Decorator): string | null;
+};

package/dist/utils/wellKnownSelectors.d.ts

@@ -0,0 +1 @@
+export declare const MODULE_CLASS_DECORATOR = "ClassDeclaration > Decorator[expression.callee.name=\"Module\"]";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@darraghor/eslint-plugin-nestjs-typed",
-    "version": "6.0.0-rc.7",
+    "version": "6.0.0-rc.8",
     "description": "Eslint rules for nestjs projects",
     "scripts": {
         "clean": "rm -Rf ./dist/",
@@ -47,7 +47,15 @@
         "url": "https://darraghoriordan.com"
     },
     "main": "dist/index.js",
-    "types": "index.d.ts",
+    "type": "commonjs",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "types": "./dist/index.d.ts",
     "dependencies": {
         "@typescript-eslint/scope-manager": "^8.21.0",
         "@typescript-eslint/utils": "^8.21.0",