@appland/scanner 1.83.0 → 1.84.0

package/built/cli/upload.d.ts

@@ -0,0 +1,5 @@
+import { CreateMapsetOptions } from '@appland/client/dist/src';
+import { ScanResults } from '../report/scanResults';
+import { UploadResponse } from '../integration/appland/scannerJob/create';
+import { RetryOptions } from '../integration/appland/retryOptions';
+export default function create(scanResults: ScanResults, appId: string, appMapDir: string, mergeKey?: string, mapsetOptions?: CreateMapsetOptions, retryOptions?: RetryOptions): Promise<UploadResponse>;

package/built/cli/validateFile.d.ts

@@ -0,0 +1 @@
+export default function (kind: string, path: string): Promise<void>;

package/built/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/built/configuration/configurationProvider.d.ts

@@ -0,0 +1,9 @@
+import Check from '../check';
+import Configuration from './types/configuration';
+import RuleInstance from '../ruleInstance';
+export declare function loadRule(ruleName: string): Promise<RuleInstance>;
+export declare function loadConfig(config: Configuration): Promise<Check[]>;
+export declare type TimestampedConfiguration = Configuration & {
+    timestampMs: number;
+};
+export declare function parseConfigFile(configPath: string): Promise<TimestampedConfiguration>;

package/built/configuration/types/checkConfig.d.ts

@@ -0,0 +1,18 @@
+import MatchEventConfig from './matchEventConfig';
+interface MatchConfig {
+    scope?: MatchEventConfig;
+    event?: MatchEventConfig;
+}
+/**
+ * CheckConfig represents the user's configuration of an Check, which is an
+ * instantiation of a Rule. Each CheckConfing is read from the scanners configuration file.
+ */
+export default interface CheckConfig {
+    rule: string;
+    id?: string;
+    scope?: string;
+    include?: MatchConfig[];
+    exclude?: MatchConfig[];
+    properties?: Record<string, unknown>;
+}
+export {};

package/built/configuration/types/configuration.d.ts

@@ -0,0 +1,7 @@
+import CheckConfig from './checkConfig';
+/**
+ * Configuration is the code representation of the scanner configuration file.
+ */
+export default interface Configuration {
+    checks: CheckConfig[];
+}

package/built/configuration/types/matchEventConfig.d.ts

@@ -0,0 +1,7 @@
+import MatchPatternConfig from './matchPatternConfig';
+declare type PropertyName = 'id' | 'type' | 'fqid' | 'query' | 'route';
+export default interface MatchEventConfig {
+    property: PropertyName;
+    test: MatchPatternConfig;
+}
+export {};

package/built/configuration/types/matchPatternConfig.d.ts

@@ -0,0 +1,6 @@
+export default interface MatchPatternConfig {
+    ignoreCase: boolean;
+    match?: RegExp;
+    include?: string;
+    equal?: string;
+}

package/built/database/index.d.ts

@@ -0,0 +1,17 @@
+import { Event } from '@appland/models';
+import { AppMapIndex, EventFilter, QueryAST } from '../types';
+import { SqliteParser } from '@appland/models/types/sqlite-parser';
+export interface SQLEvent {
+    sql: string;
+    event: Event;
+}
+export interface SQLCount {
+    count: number;
+    events: Event[];
+}
+export declare function capitalizeString(str: string): string;
+export declare function getHttpLabel(event: Event): string | undefined;
+export declare function getSqlLabelFromString(sqlString: string): string;
+export declare function isSelect(sql: string): boolean;
+export declare function sqlStrings(event: Event, appMapIndex: AppMapIndex, filter?: EventFilter): Generator<SQLEvent>;
+export declare function countJoins(ast: QueryAST | undefined, filterTable?: (table: SqliteParser.Node) => boolean): number;

package/built/database/visit.d.ts

@@ -0,0 +1,6 @@
+import { SqliteParser } from '@appland/models/types/sqlite-parser';
+declare type Callbacks = {
+    [Node in SqliteParser.Node as `${Node['type']}.${Node['variant']}`]?: (node: Node) => void;
+};
+export declare function visit(node: SqliteParser.Node, callbacks: Callbacks): void;
+export {};

package/built/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class ValidationError extends Error {
+}
+export declare class AbortError extends Error {
+}

package/built/eventUtil.d.ts

@@ -0,0 +1,3 @@
+import { CodeObject, Event } from '@appland/models';
+export declare function cloneCodeObject(sourceObject: CodeObject): CodeObject | undefined;
+export declare function cloneEvent(sourceEvent: Event): Event;

package/built/findings.d.ts

@@ -0,0 +1,3 @@
+import { FindingStatusListItem } from '@appland/client/dist/src';
+import { Finding } from './index';
+export declare function newFindings(findings: Finding[], findingStatuses: FindingStatusListItem[]): Finding[];

package/built/index.d.ts

@@ -0,0 +1,75 @@
+import { Event, Metadata } from '@appland/models';
+import Configuration from './configuration/types/configuration';
+/**
+ * Each Rule in the scanner library wants to consider some set of events as it decides whether the code should be flagged or not.
+ * A Scope is a way of declaring how these "sets" are defined. A common scope is `http_server_request`. The rule will look at each HTTP
+ * server request separately; what happens in one request is irrelevant to the next. For example, when looking for authz_before_authn, each HTTP
+ * server request is considered separately.
+ *
+ * `http_server_request` is one example of a "command". Other types of commands are: CLI commands and background jobs. Each of these has a
+ * defined beginning and end, and is logically completely separate from any other command.
+ *
+ * Some rules are relevant only to HTTP server requests - such as `http500`. Others are applicable to any kind of command - such as `nPlusOneQuery`.
+ *
+ * Finally, other rules simply want to look for a certain condition regardless of where it occurs. For example, Too many SQL joins will flag any
+ * query anywhere in the AppMap, even if it's not part of a command. This rule uses the root scope, which yields a new scope for every root-level Event
+ * (root-level = "has no parent").
+ *
+ * Ideally, AppMaps would not contain any events that are not part of a command - because without knowing the command, we don't really have any context
+ * of what the code is trying to do. But, anticipating that this may sometimes happen, "root" scope is a good choice for a rule that may flag code
+ * anywhere in the AppMap.
+ */
+export declare type ScopeName = 'root' | 'command' | 'http_client_request' | 'http_server_request' | 'transaction';
+/**
+ * Indicates the aspect of software quality that is most relevant to a rule.
+ */
+export declare type ImpactDomain = 'Security' | 'Performance' | 'Maintainability' | 'Stability';
+/**
+ * Finding is the full data structure that is created when a Rule matches an Event.
+ *
+ * The Rule only needs to return a boolean, string, or MatchResult. The scanner framework
+ * adds the rest of the information to build the complete finding.
+ */
+export interface Finding {
+    appMapFile: string;
+    checkId: string;
+    ruleId: string;
+    ruleTitle: string;
+    event: Event;
+    hash: string;
+    hash_v2: string;
+    scope: Event;
+    message: string;
+    stack: string[];
+    groupMessage?: string;
+    occurranceCount?: number;
+    relatedEvents?: Event[];
+    impactDomain?: ImpactDomain;
+    participatingEvents?: Record<string, Event>;
+    scopeModifiedDate?: Date;
+    eventsModifiedDate?: Date;
+}
+export interface Rule {
+    id: string;
+    title: string;
+    description: string;
+    url?: string;
+    labels?: string[];
+    scope?: ScopeName;
+    enumerateScope: boolean;
+    impactDomain?: ImpactDomain;
+    references?: Record<string, URL>;
+}
+export interface Check {
+    id: string;
+    scope: ScopeName;
+    impactDomain: ImpactDomain;
+    rule: Rule;
+}
+export interface ScanResults {
+    configuration: Configuration;
+    appMapMetadata: Record<string, Metadata>;
+    findings: Finding[];
+    checks: Check[];
+}
+export { default as scan } from './scan';

package/built/integration/appland/location.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { URL } from 'url';
+export default interface Location {
+    url: URL;
+}

package/built/integration/appland/retry.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { RetryOptions } from './retryOptions';
+import { RetryHandler } from '@appland/client/dist/src/retryHandler';
+export default function retry(description: string, retryOptions: RetryOptions, retryFn: () => Promise<IncomingMessage>): RetryHandler;

package/built/integration/appland/retryOptions.d.ts

@@ -0,0 +1,4 @@
+export declare type RetryOptions = {
+    maxRetries?: number;
+    retryDelay?: number;
+};

package/built/integration/appland/scannerJob/create.d.ts

@@ -0,0 +1,11 @@
+import { ScanResults } from '../../../report/scanResults';
+import Location from '../location';
+import ScannerJob from '../scannerJob';
+import { RetryOptions } from '../retryOptions';
+declare type CreateOptions = {
+    mergeKey?: string;
+};
+export interface UploadResponse extends ScannerJob, Location {
+}
+export declare function create(scanResults: ScanResults, mapsetId: number, appMapUUIDByFileName: Record<string, string>, createOptions?: CreateOptions, retryOptions?: RetryOptions): Promise<UploadResponse>;
+export {};

package/built/integration/appland/scannerJob/merge.d.ts

@@ -0,0 +1,5 @@
+import Location from '../location';
+import ScannerJob from '../scannerJob';
+export interface MergeResponse extends ScannerJob, Location {
+}
+export declare function merge(appId: string, mergeKey: string): Promise<MergeResponse>;

package/built/integration/appland/scannerJob.d.ts

@@ -0,0 +1,11 @@
+import { Configuration } from '@appland/client';
+import { ScanSummary } from '../../report/scanSummary';
+export default interface ScannerJob {
+    id: number;
+    created_at: string;
+    updated_at: string;
+    mapset_id: number;
+    merge_key?: string;
+    summary: ScanSummary;
+    configuration: Configuration;
+}

package/built/integration/github/commitStatus.d.ts

@@ -0,0 +1,3 @@
+declare type CommitStatusState = 'pending' | 'success' | 'error' | 'failure';
+export default function postCommitStatus(state: CommitStatusState, description: string): Promise<unknown>;
+export {};

package/built/integration/vars.d.ts

@@ -0,0 +1,12 @@
+declare function token(): string | undefined;
+declare function sha(): string | undefined;
+declare function pullRequestNumber(): string | undefined;
+declare function owner(): string | undefined;
+declare function repo(): string | undefined;
+declare function branch(): string | undefined;
+declare function validateToken(): void;
+declare function validateSha(): void;
+declare function validatePullRequestNumber(): void;
+declare function validateOwner(): void;
+declare function validateRepo(): void;
+export { branch, token, owner, sha, repo, pullRequestNumber, validateToken, validateOwner, validateRepo, validateSha, validatePullRequestNumber, };

package/built/lastGitOrFSModifiedDate.d.ts

@@ -0,0 +1,6 @@
+export declare function resetCache(): void;
+export declare function isCached(file: string): boolean;
+export declare function gitExists(): Promise<boolean>;
+export declare function gitModifiedDate(file: string): Promise<Date | undefined>;
+export declare function fileModifiedDate(file: string): Promise<Date | undefined>;
+export default function lastGitOrFSModifiedDate(file: string): Promise<Date | undefined>;

package/built/openapi/index.d.ts

@@ -0,0 +1,4 @@
+import OpenApiDiff from 'openapi-diff';
+import { OpenAPIV3 } from 'openapi-types';
+export * from '@appland/openapi';
+export declare const breakingChanges: (schemaHead: OpenAPIV3.Document, schemaBase: OpenAPIV3.Document) => Promise<Array<OpenApiDiff.DiffResult<'breaking'>>>;

package/built/progressReporter.d.ts

@@ -0,0 +1,16 @@
+import { AppMap, Event } from '@appland/models';
+import Check from './check';
+import { AppMapIndex, MatchResult } from './types';
+import { ScopeName } from './index';
+export default interface ProgressReporter {
+    beginAppMap(appMapFileName: string, appMap: AppMap): Promise<void>;
+    beginCheck(check: Check): Promise<void>;
+    filterScope(scopeName: ScopeName, scope: Event): Promise<void>;
+    enterScope(scope: Event): Promise<void>;
+    filterEvent(event: Event): Promise<void>;
+    matchResult(event: Event, matchResult: string | boolean | MatchResult[] | undefined): Promise<void>;
+    matchEvent(event: Event, appMapIndex: AppMapIndex): Promise<void>;
+    leaveScope(): Promise<void>;
+    endCheck(): Promise<void>;
+    endAppMap(): Promise<void>;
+}

package/built/report/findingSummary.d.ts

@@ -0,0 +1,11 @@
+/**
+ * FindingSummary summarizes the results from a single scanner across the entire scan.
+ * It's used for printing a user-friendly summary report, it's not used for machine-readable program output.
+ */
+export interface FindingSummary {
+    ruleId: string;
+    ruleTitle: string;
+    findingTotal: number;
+    findingHashes: Set<string>;
+    messages: string[];
+}

package/built/report/findingsReport.d.ts

@@ -0,0 +1,3 @@
+import { Metadata } from '@appland/models';
+import { Finding } from '../index';
+export default function (findings: Finding[], appMapMetadata: Record<string, Metadata>, ide?: string): void;

package/built/report/scanResults.d.ts

@@ -0,0 +1,19 @@
+import { Metadata } from '@appland/models';
+import Check from '../check';
+import Configuration from '../configuration/types/configuration';
+import { Finding } from '../index';
+import { ScanSummary } from './scanSummary';
+/**
+ * ScannerSummary summarizes the results of the entire scan.
+ * It's used for printing a user-friendly summary report, it's not used for machine-readable program output.
+ */
+export declare class ScanResults {
+    configuration: Configuration;
+    appMapMetadata: Record<string, Metadata>;
+    findings: Finding[];
+    checks: Check[];
+    summary: ScanSummary;
+    constructor(configuration?: Configuration, appMapMetadata?: Record<string, Metadata>, findings?: Finding[], checks?: Check[]);
+    withFindings(findings: Finding[]): ScanResults;
+    aggregate(sourceScanResults: ScanResults): void;
+}

package/built/report/scanSummary.d.ts

@@ -0,0 +1,20 @@
+import { Metadata } from '@appland/models';
+export interface AppMapMetadata {
+    labels: string[];
+    apps: string[];
+    clients: Metadata.Client[];
+    frameworks: Metadata.Framework[];
+    git: Metadata.Git[];
+    languages: Metadata.Language[];
+    recorders: Metadata.Recorder[];
+    testStatuses: ('succeeded' | 'failed')[];
+    exceptions: Metadata.Exception[];
+}
+export interface ScanSummary {
+    numAppMaps: number;
+    rules: string[];
+    ruleLabels: string[];
+    numChecks: number;
+    numFindings: number;
+    appMapMetadata: AppMapMetadata;
+}

package/built/report/summaryReport.d.ts

@@ -0,0 +1,2 @@
+import { ScanResults } from './scanResults';
+export default function (summary: ScanResults, colorize: boolean): void;

package/built/ruleChecker.d.ts

@@ -0,0 +1,13 @@
+import { Event } from '@appland/models';
+import Check from './check';
+import { AppMapIndex } from './types';
+import { Finding } from './index';
+import CheckInstance from './checkInstance';
+import ProgressReporter from './progressReporter';
+export default class RuleChecker {
+    private progress?;
+    private scopes;
+    constructor(progress?: ProgressReporter | undefined);
+    check(appMapFileName: string, appMapIndex: AppMapIndex, check: Check, findings: Finding[]): Promise<void>;
+    checkEvent(event: Event, scope: Event, appMapFileName: string, appMapIndex: AppMapIndex, checkInstance: CheckInstance, findings: Finding[]): Promise<void>;
+}

package/built/ruleInstance.d.ts

@@ -0,0 +1,6 @@
+import { Rule } from './index';
+import { RuleLogic } from './types';
+export default interface RuleInstance extends Rule {
+    Options?: any;
+    build: (options: this['Options']) => RuleLogic;
+}

package/built/rules/authzBeforeAuthn.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/circularDependency.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/deprecated-crypto-algorithm/metadata.d.ts

@@ -0,0 +1,4 @@
+import { Metadata } from '../lib/metadata';
+export declare const labels: string[];
+declare const _default: Metadata;
+export default _default;

package/built/rules/deprecated-crypto-algorithm/rule.d.ts

@@ -0,0 +1,3 @@
+import { RuleLogic } from '../../types';
+export declare const deprecatedAlgorithms: RegExp[];
+export default function rule(): RuleLogic;

package/built/rules/deserializationOfUntrustedData.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/execOfUntrustedCommand.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/http-500/metadata.d.ts

@@ -0,0 +1,3 @@
+import { Metadata } from '../lib/metadata';
+declare const _default: Metadata;
+export default _default;

package/built/rules/http-500/rule.d.ts

@@ -0,0 +1,2 @@
+import { RuleLogic } from '../../types';
+export default function rule(): RuleLogic;

package/built/rules/illegalPackageDependency.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/incompatibleHttpClientRequest.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/insecureCompare.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/jobNotCancelled.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/jwtAlgorithmNone.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { RuleLogic } from '../types';
+import { URL } from 'url';
+import RuleInstance from '../ruleInstance';
+export declare enum Labels {
+    JwtEncode = "jwt.encode"
+}
+declare class JwtAlgoritmNone implements RuleInstance {
+    readonly id = "jwt-algorithm-none";
+    readonly title = "JWT 'none' algorithm";
+    readonly impactDomain = "Security";
+    readonly enumerateScope = true;
+    readonly description: string;
+    readonly url = "https://appland.com/docs/analysis/rules-reference.html#jwt-algorithm-none";
+    readonly labels: Labels[];
+    readonly references: {
+        'CWE-345': URL;
+        'A02:2021': URL;
+        'RFC 7519': URL;
+    };
+    build(): RuleLogic;
+}
+declare const _default: JwtAlgoritmNone;
+export default _default;

package/built/rules/jwtUnverifiedSignature.d.ts

@@ -0,0 +1,23 @@
+import { RuleLogic } from '../types';
+import RuleInstance from '../ruleInstance';
+export declare enum Labels {
+    SignatureVerify = "jwt.signature.verify",
+    JwtDecode = "jwt.decode"
+}
+declare class JwtUnverifiedSignature implements RuleInstance {
+    readonly id = "jwt-unverified-signature";
+    readonly title = "Unverified signature";
+    readonly impactDomain = "Security";
+    readonly enumerateScope = true;
+    readonly description: string;
+    readonly url = "https://appland.com/docs/analysis/rules-reference.html#jwt-unverified-signature";
+    readonly labels: Labels[];
+    readonly references: {
+        'CWE-345': URL;
+        'A02:2021': URL;
+        'RFC 7519': URL;
+    };
+    build(): RuleLogic;
+}
+declare const _default: JwtUnverifiedSignature;
+export default _default;

package/built/rules/lib/analyzeDataFlow.d.ts

@@ -0,0 +1,23 @@
+import { Event, ValueBase } from '@appland/models';
+/**
+ * Value tracked with data flow analysis, along with the information about
+ * its originating event and a list of any other such values that might have
+ * been used in its generation.
+ */
+export declare type TrackedValue = {
+    value: ValueBase;
+    origin: Event;
+    parents: ReadonlyArray<TrackedValue>;
+};
+/**
+ * Tracks flow of data across the execution trace, identifying all function
+ * calls which have a tracked object as its receiver or one of the parameters.
+ * Any value such a function returns will also then become tracked.
+ * The origin chain of all values is recorded, so full provenience up to
+ * the starting set can be reconstructed.
+ * @param trackedData Initial data to track.
+ * @param startEvent The root event of the analysis.
+ * @returns Events which have a tracked piece of data as an input, each
+ * associated with the list of such inputs.
+ */
+export default function analyzeDataFlow(trackedData: ReadonlyArray<ValueBase>, startEvent: Event): Map<Event, ReadonlyArray<TrackedValue>>;

package/built/rules/lib/hasParameterOrReceiver.d.ts

@@ -0,0 +1,3 @@
+import { Event } from '@appland/models';
+declare const _default: (objectId: number) => (event: Event) => boolean;
+export default _default;

package/built/rules/lib/isCommand.d.ts

@@ -0,0 +1,2 @@
+import { Event } from '@appland/models';
+export default function isCommand(event: Event): string | undefined;

package/built/rules/lib/matchEvent.d.ts

@@ -0,0 +1,4 @@
+import MatchEventConfig from '../../configuration/types/matchEventConfig';
+import { EventFilter } from '../../types';
+export declare function buildFilter(pattern: MatchEventConfig): EventFilter;
+export declare function buildFilters(patterns: MatchEventConfig[]): EventFilter[];

package/built/rules/lib/matchPattern.d.ts

@@ -0,0 +1,4 @@
+import MatchPatternConfig from '../../configuration/types/matchPatternConfig';
+import { StringFilter } from '../../types';
+export declare function buildFilter(pattern: MatchPatternConfig): StringFilter;
+export declare function buildFilters(patterns: MatchPatternConfig[]): StringFilter[];

package/built/rules/lib/metadata.d.ts

@@ -0,0 +1,9 @@
+import { ImpactDomain, ScopeName } from '../../index';
+export declare type Metadata = {
+    title: string;
+    impactDomain: ImpactDomain;
+    references: Record<string, string>;
+    labels?: string[];
+    scope?: ScopeName;
+    enumerateScope?: boolean;
+};

package/built/rules/lib/openapiProvider.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIV3 } from 'openapi-types';
+declare const lookup: (host: string, openapiSchemata: Record<string, string>) => Promise<OpenAPIV3.Document>;
+export default lookup;

package/built/rules/lib/parseRuleDescription.d.ts

@@ -0,0 +1 @@
+export default function parseRuleDescription(id: string): string;

package/built/rules/lib/precedingEvents.d.ts

@@ -0,0 +1,2 @@
+import { Event, EventNavigator } from '@appland/models';
+export default function precedingEvents(rootEvent: Event, target: Event): Generator<EventNavigator>;

package/built/rules/lib/rpcWithoutProtection.d.ts

@@ -0,0 +1,6 @@
+import { Event, Label } from '@appland/models';
+import { RuleLogic } from '../../types';
+export interface RPCWithoutProtectionOptions {
+    get expectedLabel(): Label;
+}
+export declare function rpcWithoutProtection(candidateGenerator: (httpClientRequest: Event) => Generator<Event>, options: RPCWithoutProtectionOptions): RuleLogic;

package/built/rules/lib/sanitizesData.d.ts

@@ -0,0 +1,2 @@
+import { Event } from '@appland/models';
+export default function sanitizesData(event: Event, objectId: number, label: string): boolean;

package/built/rules/lib/util.d.ts

@@ -0,0 +1,20 @@
+import { Event, ReturnValueObject } from '@appland/models';
+export declare function collectAppMapFiles(appmapFile?: string | string[], appmapDir?: string): Promise<string[]>;
+declare function verbose(v?: boolean): boolean;
+declare function capitalize(str: string): string;
+declare function emptyValue(value: string): boolean;
+declare function responseContentType(event: Event): string | undefined;
+declare function appMapDir(appMapFileName: string): string;
+declare function isFalsey(valueObj?: ReturnValueObject): boolean;
+declare function parseValue(valueObj: ReturnValueObject): string[];
+declare const isTruthy: (valueObj?: ReturnValueObject | undefined) => boolean;
+declare function providesAuthentication(event: Event, label: string): boolean;
+declare function ideLink(filePath: string, ide: string, eventId: number): string;
+declare const toRegExp: (value: string | RegExp) => RegExp;
+declare const toRegExpArray: (value: string[] | RegExp[]) => RegExp[];
+declare const isRoot: (event: Event | undefined) => boolean;
+declare function dasherize(str: string): string;
+declare function camelize(text: string): string;
+declare function pluralize(word: string, count: number): string;
+declare function fileExists(file: string): Promise<boolean>;
+export { appMapDir, capitalize, emptyValue, fileExists, isFalsey, isTruthy, ideLink, isRoot, parseValue, camelize, dasherize, pluralize, providesAuthentication, toRegExp, responseContentType, toRegExpArray, verbose, };

package/built/rules/logoutWithoutSessionReset.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/missingAuthentication.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/missingContentType.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/nPlusOneQuery.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/queryFromInvalidPackage.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;

package/built/rules/queryFromView.d.ts

@@ -0,0 +1,3 @@
+import RuleInstance from '../ruleInstance';
+declare const RULE: RuleInstance;
+export default RULE;