@eagleoutice/flowr-dev/linter/linter-rules.d.ts

Static Dataflow Analyzer and Program Slicer for the R Programming Language

import type { LintingRule } from './linter-format';
/**
 * The registry of currently supported linting rules.
 * A linting rule can be executed on a dataflow pipeline result using {@link executeLintingRule}.
 */
export declare const LintingRules: {
    readonly 'deprecated-functions': {
        readonly createSearch: (_config: import("./rules/function-finder-util").FunctionsToDetectConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter", "with"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/function-finder-util").FunctionsToDetectConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/function-finder-util").FunctionsResult[];
            '.meta': import("./rules/function-finder-util").FunctionsMetadata;
        }>;
        readonly prettyPrint: {
            query: (result: import("./rules/function-finder-util").FunctionsResult) => string;
            full: (result: import("./rules/function-finder-util").FunctionsResult) => string;
        };
        readonly info: {
            readonly name: "Deprecated Functions";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Deprecated, import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.Usability, import("./linter-tags").LintingRuleTag.Reproducibility];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly description: "Marks deprecated functions that should not be used anymore.";
            readonly defaultConfig: {
                readonly fns: readonly ["all_equal", "arrange_all", "distinct_all", "filter_all", "group_by_all", "summarise_all", "mutate_all", "select_all", "vars", "all_vars", "id", "failwith", "select_vars", "rename_vars", "select_var", "current_vars", "bench_tbls", "compare_tbls", "compare_tbls2", "eval_tbls", "eval_tbls2", "location", "changes", "combine", "do", "funs", "add_count_", "add_tally_", "arrange_", "count_", "distinct_", "do_", "filter_", "funs_", "group_by_", "group_indices_", "mutate_", "tally_", "transmute_", "rename_", "rename_vars_", "select_", "select_vars_", "slice_", "summarise_", "summarize_", "summarise_each", "src_local", "tbl_df", "add_rownames", "group_nest", "group_split", "with_groups", "nest_by", "progress_estimated", "recode", "sample_n", "top_n", "transmute", "fct_explicit_na", "aes_", "aes_auto", "annotation_logticks", "is.Coord", "coord_flip", "coord_map", "is.facet", "fortify", "is.ggproto", "guide_train", "is.ggplot", "qplot", "is.theme", "gg_dep", "liply", "isplit2", "list_along", "cross", "invoke", "at_depth", "prepend", "rerun", "splice", "`%@%`", "rbernoulli", "rdunif", "when", "update_list", "map_raw", "accumulate", "reduce_right", "flatten", "map_dfr", "as_vector", "transpose", "melt_delim", "melt_fwf", "melt_table", "read_table2", "str_interp", "as_tibble", "data_frame", "tibble_", "data_frame_", "lst_", "as_data_frame", "as.tibble", "frame_data", "trunc_mat", "is.tibble", "tidy_names", "set_tidy_names", "repair_names", "extract_numeric", "complete_", "drop_na_", "expand_", "crossing_", "nesting_", "extract_", "fill_", "gather_", "nest_", "separate_rows_", "separate_", "spread_", "unite_", "unnest_", "extract", "gather", "nest_legacy", "separate_rows", "separate", "spread"];
            };
        };
    };
    readonly 'file-path-validity': {
        readonly createSearch: (config: import("./rules/file-path-validity").FilePathValidityConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"from-query", ["with"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/file-path-validity").FilePathValidityConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/file-path-validity").FilePathValidityResult[];
            ".meta": import("./rules/file-path-validity").FilePathValidityMetadata;
        }>;
        readonly info: {
            readonly name: "File Path Validity";
            readonly description: "Checks whether file paths used in read and write operations are valid and point to existing files.";
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Robustness, import("./linter-tags").LintingRuleTag.Reproducibility, import("./linter-tags").LintingRuleTag.Bug, import("./linter-tags").LintingRuleTag.QuickFix];
            readonly defaultConfig: {
                readonly additionalReadFunctions: readonly [];
                readonly additionalWriteFunctions: readonly [];
                readonly includeUnknown: false;
                readonly checkUrls: false;
            };
        };
        readonly prettyPrint: {
            readonly query: (result: import("./rules/file-path-validity").FilePathValidityResult) => string;
            readonly full: (result: import("./rules/file-path-validity").FilePathValidityResult) => string;
        };
    };
    readonly 'seeded-randomness': {
        readonly createSearch: (config: import("./rules/seeded-randomness").SeededRandomnessConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter", "with", "filter", "with"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/seeded-randomness").SeededRandomnessConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: {
                involvedId: import("../r-bridge/lang-4.x/ast/model/processing/node-id").NodeId;
                certainty: import("./linter-format").LintingResultCertainty;
                function: import("../dataflow/environments/identifier").BrandedIdentifier;
                loc: [startLine: number, startColumn: number, endLine: number, endColumn: number, f?: string | undefined];
            }[];
            '.meta': import("./rules/seeded-randomness").SeededRandomnessMeta;
        }>;
        readonly info: {
            readonly defaultConfig: {
                readonly randomnessProducers: {
                    type: "function" | "assignment";
                    name: string;
                }[];
                readonly randomnessConsumers: readonly [...import("../dataflow/environments/identifier").BrandedIdentifier[], "princomp", "pointLabel", "some", "rbernoulli", "rdunif", "generateSeedVectors", "rvonmises", "rxor", "rmvnorm", "randomForest", "permuted", "permute", "shuffle", "shuffleSet", "data_shuffle", "sample_frac", "sample_n"];
            };
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Robustness, import("./linter-tags").LintingRuleTag.Reproducibility];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly name: "Seeded Randomness";
            readonly description: "Checks whether randomness-based function calls are preceded by a random seed generation function. For consistent reproducibility, functions that use randomness should only be called after a constant random seed is set using a function like `set.seed`.";
        };
        readonly prettyPrint: {
            readonly query: (result: import("./rules/seeded-randomness").SeededRandomnessResult, _meta: import("./rules/seeded-randomness").SeededRandomnessMeta) => string;
            readonly full: (result: import("./rules/seeded-randomness").SeededRandomnessResult, _meta: import("./rules/seeded-randomness").SeededRandomnessMeta) => string;
        };
    };
    readonly 'absolute-file-paths': {
        readonly createSearch: (config: import("./rules/absolute-path").AbsoluteFilePathConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"from-query", ["unique"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/absolute-path").AbsoluteFilePathConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/absolute-path").AbsoluteFilePathResult[];
            ".meta": import("./rules/absolute-path").AbsoluteFilePathMetadata;
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./rules/absolute-path").AbsoluteFilePathResult) => string;
            readonly full: (result: import("./rules/absolute-path").AbsoluteFilePathResult) => string;
        };
        readonly info: {
            readonly name: "Absolute Paths";
            readonly description: "Checks whether file paths are absolute.";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Robustness, import("./linter-tags").LintingRuleTag.Reproducibility, import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.QuickFix];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly defaultConfig: {
                readonly include: {
                    readonly constructed: true;
                    readonly allStrings: false;
                };
                readonly additionalPathFunctions: readonly [];
                readonly absolutePathRegex: undefined;
                readonly useAsWd: "@project";
                readonly ignoreUrls: true;
            };
        };
    };
    readonly 'unused-definitions': {
        readonly createSearch: (config: import("./rules/unused-definition").UnusedDefinitionConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/unused-definition").UnusedDefinitionConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/unused-definition").UnusedDefinitionResult[];
            ".meta": import("./rules/unused-definition").UnusedDefinitionMetadata;
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./rules/unused-definition").UnusedDefinitionResult) => string;
            readonly full: (result: import("./rules/unused-definition").UnusedDefinitionResult) => string;
        };
        readonly info: {
            readonly name: "Unused Definitions";
            readonly description: "Checks for unused definitions.";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Readability, import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.QuickFix];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly defaultConfig: {
                readonly includeFunctionDefinitions: true;
                readonly excludeExportedDefinitions: true;
            };
        };
    };
    readonly 'naming-convention': {
        readonly createSearch: (_config: import("./rules/naming-convention").NamingConventionConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/naming-convention").NamingConventionConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/naming-convention").NamingConventionResult[];
            '.meta': {
                numMatches: number;
                numBreak: number;
            };
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./rules/naming-convention").NamingConventionResult) => string;
            readonly full: (result: import("./rules/naming-convention").NamingConventionResult) => string;
        };
        readonly info: {
            readonly name: "Naming Convention";
            readonly certainty: import("./linter-format").LintingRuleCertainty.OverApproximative;
            readonly description: "Checks whether the symbols conform to a certain naming convention";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Style, import("./linter-tags").LintingRuleTag.QuickFix];
            readonly activeByDefault: false;
            readonly defaultConfig: {
                readonly caseing: "auto";
                readonly ignoreNonAlpha: true;
            };
        };
    };
    readonly 'network-functions': {
        readonly createSearch: (config: import("./rules/network-functions").NetworkFunctionsConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter", "with", "filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (e: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, c: import("./rules/network-functions").NetworkFunctionsConfig, d: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/function-finder-util").FunctionsResult[];
            '.meta': import("./rules/function-finder-util").FunctionsMetadata;
        }>;
        readonly prettyPrint: {
            query: (result: import("./rules/function-finder-util").FunctionsResult) => string;
            full: (result: import("./rules/function-finder-util").FunctionsResult) => string;
        };
        readonly info: {
            readonly name: "Network Functions";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Reproducibility, import("./linter-tags").LintingRuleTag.Security, import("./linter-tags").LintingRuleTag.Performance, import("./linter-tags").LintingRuleTag.Smell];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly description: "Marks network functions that execute network operations, such as downloading files or making HTTP requests.";
            readonly defaultConfig: {
                readonly fns: {
                    name: import("../dataflow/environments/identifier").Identifier;
                    onlyTriggerWithArgument: RegExp;
                }[];
            };
        };
    };
    readonly 'dataframe-access-validation': {
        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", [], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/dataframe-access-validation").DataFrameAccessValidationConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/dataframe-access-validation").DataFrameAccessValidationResult[];
            '.meta': import("./rules/dataframe-access-validation").DataFrameAccessValidationMetadata;
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./rules/dataframe-access-validation").DataFrameAccessValidationResult) => string;
            readonly full: (result: import("./rules/dataframe-access-validation").DataFrameAccessValidationResult) => string;
        };
        readonly info: {
            readonly name: "Dataframe Access Validation";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Bug, import("./linter-tags").LintingRuleTag.Usability, import("./linter-tags").LintingRuleTag.Reproducibility];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly description: "Validates the existence of accessed columns and rows of dataframes.";
            readonly defaultConfig: {
                readonly readLoadedData: false;
            };
        };
    };
    readonly 'dead-code': {
        readonly createSearch: (config: import("./rules/dead-code").DeadCodeConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with", "filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, _config: import("./rules/dead-code").DeadCodeConfig, _data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => {
            results: import("./linter-format").LintingResult[];
        };
        readonly prettyPrint: {
            readonly query: (result: import("./linter-format").LintingResult) => string;
            readonly full: (result: import("./linter-format").LintingResult) => string;
        };
        readonly info: {
            readonly name: "Dead Code";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.Usability, import("./linter-tags").LintingRuleTag.Reproducibility];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly description: "Marks areas of code that are never reached during execution.";
            readonly defaultConfig: {};
        };
    };
    readonly 'useless-loop': {
        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, useLessLoopConfig: import("./rules/useless-loop").UselessLoopConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: {
                certainty: import("./linter-format").LintingResultCertainty.Certain;
                name: string;
                loc: [startLine: number, startColumn: number, endLine: number, endColumn: number, f?: string | undefined];
                involvedId: import("../r-bridge/lang-4.x/ast/model/processing/node-id").NodeId;
            }[];
            '.meta': {
                numOfUselessLoops: number;
            };
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./rules/useless-loop").UselessLoopResult) => string;
            readonly full: (result: import("./rules/useless-loop").UselessLoopResult) => string;
        };
        readonly info: {
            readonly name: "Useless Loops";
            readonly description: "Detect loops which only iterate once";
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.Readability];
            readonly defaultConfig: {
                readonly loopyFunctions: Set<import("../dataflow/environments/built-in-proc-name").BuiltInProcName>;
            };
        };
    };
    readonly 'problematic-inputs': {
        readonly createSearch: (config: import("./rules/problematic-inputs").ProblematicInputsConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"from-query", [], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/problematic-inputs").ProblematicInputsConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/problematic-inputs").ProblematicInputsResult[];
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./rules/problematic-inputs").ProblematicInputsResult) => string;
            readonly full: (result: import("./rules/problematic-inputs").ProblematicInputsResult) => string;
        };
        readonly info: {
            readonly name: "Problematic inputs";
            readonly description: "Detects uses of dynamic calls (e.g. eval, system) with non-constant inputs, and graphics-device calls (pdf, postscript) where a filename starts with '|' indicating a pipe command injection.";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Security, import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.Readability, import("./linter-tags").LintingRuleTag.Performance];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly defaultConfig: {
                readonly consider: readonly string[];
                readonly pipeCommandFunctions: readonly import("./rules/problematic-inputs").PipeCommandFunctionSpec[];
            };
        };
    };
    readonly 'stop-call': {
        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"get", ["filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, _config: import("../util/objects").MergeableRecord, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("ts-essentials").Writable<import("./rules/stop-with-call-arg").StopWithCallResult>[];
            '.meta': import("./rules/stop-with-call-arg").StopWithCallMetadata;
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./linter-format").LintingResult) => string;
            readonly full: (result: import("./linter-format").LintingResult) => string;
        };
        readonly info: {
            readonly name: "Stop without call.=False argument";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Smell];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly description: "Checks whether stop calls without call. argument set to FALSE are used.";
            readonly defaultConfig: {};
        };
    };
    readonly 'roxygen-arguments': {
        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter", "with"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, _config: import("../util/objects").MergeableRecord) => {
            results: import("ts-essentials").Writable<import("./rules/roxygen-arguments").RoxygenArgsResult>[];
            '.meta': {};
        };
        readonly prettyPrint: {
            readonly query: (result: import("./rules/roxygen-arguments").RoxygenArgsResult) => string;
            readonly full: (result: import("./rules/roxygen-arguments").RoxygenArgsResult) => string;
        };
        readonly info: {
            readonly name: "Roxygen Arguments";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.Documentation, import("./linter-tags").LintingRuleTag.Style];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly description: "Checks whether a function has undocumented or overdocumented parameters";
            readonly defaultConfig: {};
        };
    };
    readonly 'software-has-license': {
        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"from-query", [], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
        readonly processSearchResult: (_elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/software-has-license").SoftwareHasLicenseConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => {
            results: import("./rules/software-has-license").SoftwareHasLicenseResult[];
            '.meta': {};
        };
        readonly prettyPrint: {
            readonly query: (result: import("./rules/software-has-license").SoftwareHasLicenseResult) => string;
            readonly full: (result: import("./rules/software-has-license").SoftwareHasLicenseResult) => string;
        };
        readonly info: {
            readonly name: "Software Has License";
            readonly description: "Checks whether the software project provides a license (via a LICENSE file or the DESCRIPTION file License field).";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Documentation, import("./linter-tags").LintingRuleTag.Usability];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly defaultConfig: {
                readonly checkDescriptionFile: true;
            };
        };
    };
    readonly 'software-has-tests': {
        readonly createSearch: (config: import("./rules/software-has-tests").SoftwareHasTestsConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"from-query", [], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, _config: import("./rules/software-has-tests").SoftwareHasTestsConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => {
            results: import("./rules/software-has-tests").SoftwareHasTestsResult[];
            '.meta': {
                testFilesFound: number;
                testCallsFound: number;
            };
        };
        readonly prettyPrint: {
            readonly query: (result: import("./rules/software-has-tests").SoftwareHasTestsResult) => string;
            readonly full: (result: import("./rules/software-has-tests").SoftwareHasTestsResult) => string;
        };
        readonly info: {
            readonly name: "Software Has Tests";
            readonly description: "Checks whether the software project has tests (test files in a test directory or test function calls in R code).";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Usability, import("./linter-tags").LintingRuleTag.Reproducibility];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly defaultConfig: {
                readonly additionalTestFunctions: readonly [];
            };
        };
    };
    readonly 'no-leaked-credentials': {
        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/no-leaked-credentials").NoLeakedCredentialsConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/no-leaked-credentials").NoLeakedCredentialsResult[];
            ".meta": import("./rules/no-leaked-credentials").NoLeakedCredentialsMetadata;
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./rules/no-leaked-credentials").NoLeakedCredentialsResult) => string;
            readonly full: (result: import("./rules/no-leaked-credentials").NoLeakedCredentialsResult) => string;
        };
        readonly info: {
            readonly name: "No Leaked Credentials";
            readonly description: "Detects hardcoded credentials assigned to variables whose names suggest they hold passwords, tokens, or API keys, or whose values match known credential formats (AWS, GitHub, Slack, Stripe, SSH).";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Security, import("./linter-tags").LintingRuleTag.Experimental, import("./linter-tags").LintingRuleTag.Smell];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly defaultConfig: {
                readonly credentialNamePattern: "(?:password|passwd|pwd|secret|api[_.]?key|api[_.]?token|access[_.]?token|auth[_.]?token|bearer[_.]?token|private[_.]?key|credential)";
                readonly credentialValuePattern: string;
            };
        };
    };
    readonly 'undefined-symbol': {
        readonly createSearch: (_config: import("./rules/undefined-symbol").UndefinedSymbolConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/undefined-symbol").UndefinedSymbolConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/undefined-symbol").UndefinedSymbolResult[];
            '.meta': import("./rules/undefined-symbol").UndefinedSymbolMetadata;
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./rules/undefined-symbol").UndefinedSymbolResult) => string;
            readonly full: (result: import("./rules/undefined-symbol").UndefinedSymbolResult) => string;
        };
        readonly info: {
            readonly name: "Undefined Symbol";
            readonly certainty: import("./linter-format").LintingRuleCertainty.OverApproximative;
            readonly description: "Flags functions and variables that are neither defined locally, a base R builtin, nor exported by a loaded package.";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Bug, import("./linter-tags").LintingRuleTag.Experimental];
            readonly defaultConfig: {
                readonly checkFunctions: true;
                readonly checkVariables: true;
                readonly checkSubscripts: false;
            };
        };
    };
    readonly 'syntactically-valid': {
        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"from", [], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
        readonly processSearchResult: (_elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/syntactically-valid").SyntacticallyValidConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./rules/syntactically-valid").SyntacticallyValidResult[];
            ".meta": import("./rules/syntactically-valid").SyntacticallyValidMetadata;
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./rules/syntactically-valid").SyntacticallyValidResult) => string;
            readonly full: (result: import("./rules/syntactically-valid").SyntacticallyValidResult) => string;
        };
        readonly info: {
            readonly name: "Syntactically Valid";
            readonly description: "Checks whether the code is free of syntax errors, using the configured (error-tolerant) parser, and offers extensible quick-fixes to repair them.";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Bug, import("./linter-tags").LintingRuleTag.Robustness, import("./linter-tags").LintingRuleTag.QuickFix];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly activeByDefault: false;
            readonly defaultConfig: {
                readonly disabledFixes: readonly [];
                readonly preferFix: "remove";
            };
        };
    };
    readonly 'unclosed-connection': {
        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/unclosed-connection").UnclosedConnectionConfig, data: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>) => Promise<{
            results: import("./linter-format").LintingResult[];
            '.meta': {
                totalOpened: number;
                totalClosed: number;
            };
        }>;
        readonly prettyPrint: {
            readonly query: (result: import("./linter-format").LintingResult) => string;
            readonly full: (result: import("./linter-format").LintingResult) => string;
        };
        readonly info: {
            readonly name: "Unclosed Connection";
            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Robustness, import("./linter-tags").LintingRuleTag.Smell];
            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
            readonly description: "Flags connections that are opened but not closed on every path opening them.";
            readonly defaultConfig: {
                readonly openFns: readonly [];
                readonly closeFns: readonly [];
            };
        };
    };
};
export type LintingRuleNames = keyof typeof LintingRules;
export type LintingRuleMetadata<Name extends LintingRuleNames> = typeof LintingRules[Name] extends LintingRule<infer _Result, infer Metadata, infer _Config, infer _Info, infer _Elements> ? Metadata : never;
export type LintingRuleResult<Name extends LintingRuleNames> = typeof LintingRules[Name] extends LintingRule<infer Result, infer _Metadata, infer _Config, infer _Info, infer _Elements> ? Result : never;
export type LintingRuleConfig<Name extends LintingRuleNames> = typeof LintingRules[Name] extends LintingRule<infer _Result, infer _Metadata, infer Config, infer _Info, infer _Elements> ? Config : never;