@appland/scanner 1.83.0 → 1.83.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [@appland/scanner-v1.83.1](https://github.com/getappmap/appmap-js/compare/@appland/scanner-v1.83.0...@appland/scanner-v1.83.1) (2023-10-02)
+
+
+### Bug Fixes
+
+* Export primary types ([5b845d6](https://github.com/getappmap/appmap-js/commit/5b845d60bf3a200e98f29011f8084468bb0e5f43))
+
 # [@appland/scanner-v1.83.0](https://github.com/getappmap/appmap-js/compare/@appland/scanner-v1.82.1...@appland/scanner-v1.83.0) (2023-09-01)
 
 

package/built/algorithms/dataStructures/graph/Graph.d.ts

@@ -0,0 +1,29 @@
+import GraphEdge from './GraphEdge';
+import GraphVertex from './GraphVertex';
+export default class Graph {
+    vertices: Record<string, GraphVertex>;
+    edges: Record<string, GraphEdge>;
+    isDirected: boolean;
+    /**
+     * @param {boolean} isDirected
+     */
+    constructor(isDirected?: boolean);
+    get vertexCount(): number;
+    addVertex(newVertex: GraphVertex): Graph;
+    getVertexByKey(vertexKey: string): GraphVertex | null;
+    getNeighbors(vertex: GraphVertex): GraphVertex[];
+    getAllVertices(): GraphVertex[];
+    getAllEdges(): GraphEdge[];
+    addEdge(edge: GraphEdge): Graph;
+    deleteEdge(edge: GraphEdge): void;
+    findEdge(startVertex: GraphVertex, endVertex: GraphVertex): GraphEdge | null;
+    findVertexByKey(vertexKey: string): GraphVertex | null;
+    getWeight(): number;
+    /**
+     * Reverse all the edges in directed graph.
+     */
+    reverse(): Graph;
+    getVerticesIndices(): Record<string, number>;
+    getAdjacencyMatrix(): number[][];
+    toString(): string;
+}

package/built/algorithms/dataStructures/graph/GraphEdge.d.ts

@@ -0,0 +1,10 @@
+import GraphVertex from './GraphVertex';
+export default class GraphEdge {
+    startVertex: GraphVertex;
+    endVertex: GraphVertex;
+    weight: number;
+    constructor(startVertex: GraphVertex, endVertex: GraphVertex, weight?: number);
+    getKey(): string;
+    reverse(): GraphEdge;
+    toString(): string;
+}

package/built/algorithms/dataStructures/graph/GraphVertex.d.ts

@@ -0,0 +1,21 @@
+import GraphEdge from './GraphEdge';
+import LinkedList from '../linked-list/LinkedList';
+export default class GraphVertex {
+    value: string;
+    edges: LinkedList<GraphEdge>;
+    /**
+     * @param {*} value
+     */
+    constructor(value: string);
+    addEdge(edge: GraphEdge): GraphVertex;
+    deleteEdge(edge: GraphEdge): void;
+    getNeighbors(): GraphVertex[];
+    getEdges(): GraphEdge[];
+    getDegree(): number;
+    hasEdge(requiredEdge: GraphEdge): boolean;
+    hasNeighbor(vertex: GraphVertex): boolean;
+    findEdge(vertex: GraphVertex): GraphEdge | null;
+    getKey(): string;
+    deleteAllEdges(): GraphVertex;
+    toString(callback?: undefined | ((value: string) => string)): string;
+}

package/built/algorithms/dataStructures/linked-list/LinkedList.d.ts

@@ -0,0 +1,16 @@
+import LinkedListNode from './LinkedListNode';
+import Comparator from '../../utils/Comparator';
+export default class LinkedList<T> {
+    head: LinkedListNode<T> | null;
+    tail: LinkedListNode<T> | null;
+    compare: Comparator<T>;
+    constructor(comparatorFunction: (a: T, b: T) => number);
+    prepend(value: T): LinkedList<T>;
+    append(value: T): LinkedList<T>;
+    delete(value: T): LinkedListNode<T> | null;
+    find(value?: T | undefined, callback?: undefined | ((value: T) => boolean)): LinkedListNode<T> | null;
+    deleteTail(): LinkedListNode<T> | null;
+    deleteHead(): LinkedListNode<T> | null;
+    toArray(): LinkedListNode<T>[];
+    toString(callback?: undefined | ((value: T) => string)): string;
+}

package/built/algorithms/dataStructures/linked-list/LinkedListNode.d.ts

@@ -0,0 +1,6 @@
+export default class LinkedListNode<T> {
+    value: T;
+    next: LinkedListNode<T> | null;
+    constructor(value: T, next?: null | LinkedListNode<T>);
+    toString(callback?: undefined | ((value: T) => string)): string;
+}

package/built/algorithms/graph/depth-first-search/index.d.ts

@@ -0,0 +1,8 @@
+import Graph from '../../dataStructures/graph/Graph';
+import GraphVertex from '../../dataStructures/graph/GraphVertex';
+export interface Callbacks {
+    allowTraversal: (previousVertex: GraphVertex | null, currentVertex: GraphVertex, nextVertex: GraphVertex) => boolean;
+    enterVertex: (currentVertex: GraphVertex, previousVertex: GraphVertex | null) => boolean;
+    leaveVertex: (currentVertex: GraphVertex, previousVertex: GraphVertex | null) => void;
+}
+export declare function depthFirstSearch(graph: Graph, startVertex: GraphVertex, callbacks: Callbacks): void;

package/built/algorithms/graph/detect-cycle/index.d.ts

@@ -0,0 +1,8 @@
+import Graph from '../../dataStructures/graph/Graph';
+import GraphVertex from '../../dataStructures/graph/GraphVertex';
+/**
+ * Detect cycle in directed graph using Depth First Search.
+ *
+ * @returns the cycle of vertexes, not including the final vertex which is the same as the first.
+ */
+export default function detectDirectedCycle(graph: Graph): GraphVertex[][];

package/built/algorithms/hash/hashV1.d.ts

@@ -0,0 +1,6 @@
+import { Event } from '@appland/models';
+export default class HashV1 {
+    private hash;
+    constructor(ruleId: string, findingEvent: Event, relatedEvents: Event[]);
+    digest(): string;
+}

package/built/algorithms/hash/hashV2.d.ts

@@ -0,0 +1,53 @@
+import { Event } from '@appland/models';
+/**
+ * Captures stack entries from distinct packages. Ancestors of the event are traversed up to the
+ * command or root. Then, starting from the command or root, subsequent events which come from the
+ * same package as their preceding event are removed. Then the last N entries remaining in the
+ * stack are collected.
+ *
+ * @param event leaf event
+ * @param participatingEvents output collector
+ * @param depth number of events to include in the output
+ */
+export declare function captureStack(event: Event, depth?: number): Event[];
+/**
+ * Builds a hash (digest) of a finding. The digest is constructed by first building a canonical
+ * string of the finding, of the form:
+ *
+ * ```
+ * [
+ *   algorithmVersion=2
+ *   rule=<rule-id>
+ *   findingEvent.<property1>=value1
+ *   ...
+ *   findingEvent.<propertyN>=valueN
+ *   participatingEvent.<eventName1>=value1
+ *   ...
+ *   participatingEvent.<eventName1>=valueN
+ *   ...
+ *   participatingEvent.<eventNameN>=value1
+ *   ...
+ *   participatingEvent.<eventNameN>=valueN
+ *   stack[1]=value1
+ *   ...
+ *   stack[1]=valueN
+ *   ...
+ *   stack[3]=value1
+ *   ...
+ *   stack[3]=valueN
+ * ]
+ * ```
+ *
+ * Participating events are sorted by the event name. Properties of each event are sorted by
+ * the property name. Event properties are provided by `Event#stableProperties`.
+ *
+ * The partial stack included in the finding hash removes subsequent function calls from the
+ * same package.
+ */
+export default class HashV2 {
+    private hashEntries;
+    private hash;
+    constructor(ruleId: string, findingEvent: Event, participatingEvents: Record<string, Event>);
+    get canonicalString(): string;
+    digest(): string;
+}

package/built/algorithms/utils/Comparator.d.ts

@@ -0,0 +1,11 @@
+export default class Comparator<T> {
+    compare: (a: T, b: T) => number;
+    constructor(compareFunction: (a: T, b: T) => number);
+    static defaultCompareFunction<T>(a: T, b: T): number;
+    equal(a: T, b: T): boolean;
+    lessThan(a: T, b: T): boolean;
+    greaterThan(a: T, b: T): boolean;
+    lessThanOrEqual(a: T, b: T): boolean;
+    greaterThanOrEqual(a: T, b: T): boolean;
+    reverse(): void;
+}

package/built/analyzer/recordSecrets.d.ts

@@ -0,0 +1,6 @@
+import { Event } from '@appland/models';
+export declare type Secret = {
+    generatorEvent: Event;
+    value: string;
+};
+export default function (secrets: Secret[], e: Event): void;

package/built/analyzer/secretsRegexes.d.ts

@@ -0,0 +1,5 @@
+declare const REGEXES: {
+    [key: string]: RegExp[];
+};
+export declare const looksSecret: (string: string) => boolean;
+export default REGEXES;

package/built/appMapIndex.d.ts

@@ -0,0 +1,8 @@
+import { AppMap, Event } from '@appland/models';
+import { QueryAST } from './types';
+export default class AppMapIndex {
+    appMap: AppMap;
+    constructor(appMap: AppMap);
+    sqlAST(event: Event): QueryAST | undefined;
+    sqlNormalized(event: Event): string;
+}

package/built/check.d.ts

@@ -0,0 +1,18 @@
+import { Event } from '@appland/models';
+import { ImpactDomain, ScopeName } from './index';
+import { AppMapIndex, EventFilter } from './types';
+import RuleInstance from './ruleInstance';
+export default class Check {
+    rule: RuleInstance;
+    id: string;
+    impactDomain?: ImpactDomain;
+    options: Record<string, unknown>;
+    scope: ScopeName;
+    includeScope: EventFilter[];
+    excludeScope: EventFilter[];
+    includeEvent: EventFilter[];
+    excludeEvent: EventFilter[];
+    constructor(rule: RuleInstance, options?: Record<string, unknown>);
+    filterScope(event: Event, appMapIndex: AppMapIndex): boolean;
+    toString(): string;
+}

package/built/checkInstance.d.ts

@@ -0,0 +1,16 @@
+import { Event } from '@appland/models';
+import Check from './check';
+import { AppMapIndex, RuleLogic } from './types';
+import { ImpactDomain, ScopeName } from './index';
+export default class CheckInstance {
+    check: Check;
+    ruleLogic: RuleLogic;
+    constructor(check: Check);
+    get checkImpactDomain(): ImpactDomain | undefined;
+    get checkId(): string;
+    get ruleId(): string;
+    get title(): string;
+    get scope(): ScopeName;
+    get enumerateScope(): boolean;
+    filterEvent(event: Event, appMapIndex: AppMapIndex): boolean;
+}

package/built/cli/appmapDirFromConfig.d.ts

@@ -0,0 +1 @@
+export declare function appmapDirFromConfig(): Promise<string | undefined>;

package/built/cli/ci/command.d.ts

@@ -0,0 +1,8 @@
+import { Arguments, Argv } from 'yargs';
+declare const _default: {
+    command: string;
+    describe: string;
+    builder(args: Argv): Argv;
+    handler(options: Arguments): Promise<void>;
+};
+export default _default;

package/built/cli/ci/options.d.ts

@@ -0,0 +1,10 @@
+import ScanOptions from '../scanOptions';
+export default interface CommandOptions extends ScanOptions {
+    fail?: boolean;
+    upload: boolean;
+    updateCommitStatus: boolean;
+    mergeKey?: string;
+    branch?: string;
+    commit?: string;
+    environment?: string;
+}

package/built/cli/codeVersionArgs.d.ts

@@ -0,0 +1,2 @@
+import { Argv } from 'yargs';
+export default function (args: Argv): void;

package/built/cli/exitCode.d.ts

@@ -0,0 +1,6 @@
+export declare enum ExitCode {
+    ValidationError = 1,
+    AbortError = 2,
+    RuntimeError = 3,
+    Finding = 10
+}

package/built/cli/fail.d.ts

@@ -0,0 +1 @@
+export default function fail(numFindings: number): void;

package/built/cli/handleWorkingDirectory.d.ts

@@ -0,0 +1 @@
+export declare function handleWorkingDirectory(directory?: string): void;

package/built/cli/merge/command.d.ts

@@ -0,0 +1,8 @@
+import { Arguments, Argv } from 'yargs';
+declare const _default: {
+    command: string;
+    describe: string;
+    builder(args: Argv): Argv;
+    handler(options: Arguments): Promise<void>;
+};
+export default _default;

package/built/cli/merge/options.d.ts

@@ -0,0 +1,7 @@
+export default interface CommandOptions {
+    verbose?: boolean;
+    mergeKey: string;
+    app?: string;
+    fail?: boolean;
+    updateCommitStatus: boolean;
+}

package/built/cli/reportUploadURL.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { URL } from 'url';
+export default function reportUploadURL(numFindings: number, url?: URL): void;

package/built/cli/resolveAppId.d.ts

@@ -0,0 +1 @@
+export default function (appIdArg: string | undefined, appMapDir: string | undefined): Promise<string>;

package/built/cli/scan/breakpoint.d.ts

@@ -0,0 +1,41 @@
+import { AppMap } from '@appland/client';
+import { Event } from '@appland/models';
+import Check from '../../check';
+import { MatchResult } from '../../types';
+export declare type ExecutionContext = {
+    counter: number;
+    depth: number;
+    eventName: string;
+    appMap?: AppMap;
+    appMapFileName?: string;
+    check?: Check;
+    event?: Event;
+    matchResult?: string | boolean | MatchResult[];
+};
+export interface Breakpoint {
+    condition: (context: ExecutionContext) => boolean;
+}
+export declare class BreakOnCounter implements Breakpoint {
+    private readonly counter;
+    constructor(counter: number);
+    condition(context: ExecutionContext): boolean;
+    toString(): string;
+}
+export declare class BreakOnEvent implements Breakpoint {
+    eventName: RegExp;
+    constructor(eventName: string);
+    condition(context: ExecutionContext): boolean;
+    toString(): string;
+}
+export declare class BreakOnLabel implements Breakpoint {
+    label: RegExp;
+    constructor(label: string);
+    condition(context: ExecutionContext): boolean;
+    toString(): string;
+}
+export declare class BreakOnCodeObject implements Breakpoint {
+    codeObject: RegExp;
+    constructor(codeObject: string);
+    condition(context: ExecutionContext): boolean;
+    toString(): string;
+}

package/built/cli/scan/command.d.ts

@@ -0,0 +1,8 @@
+import { Arguments, Argv } from 'yargs';
+declare const _default: {
+    command: string;
+    describe: string;
+    builder(args: Argv): Argv;
+    handler(options: Arguments): Promise<void>;
+};
+export default _default;

package/built/cli/scan/formatReport.d.ts

@@ -0,0 +1,2 @@
+import { ScanResults } from '../../report/scanResults';
+export declare function formatReport(rawScanResults: ScanResults): string;

package/built/cli/scan/interactiveScan.d.ts

@@ -0,0 +1,8 @@
+import Configuration from '../../configuration/types/configuration';
+declare type InteractiveScanOptions = {
+    configuration: Configuration;
+    appmapFile?: string | string[];
+    appmapDir?: string;
+};
+export default function interactiveScan(options: InteractiveScanOptions): Promise<void>;
+export {};

package/built/cli/scan/options.d.ts

@@ -0,0 +1,8 @@
+import ScanOptions from '../scanOptions';
+export default interface CommandOptions extends ScanOptions {
+    all: boolean;
+    interactive: boolean;
+    watch: boolean;
+    appmapFile?: string | string[];
+    ide?: string;
+}

package/built/cli/scan/scanner.d.ts

@@ -0,0 +1,9 @@
+import { FindingStatusListItem } from '@appland/client/dist/src';
+import Configuration from '../../configuration/types/configuration';
+import { ScanResults } from '../../report/scanResults';
+export interface Scanner {
+    scan(): Promise<ScanResults>;
+    scan(skipErrors: boolean): Promise<ScanResults>;
+    fetchFindingStatus(appId?: string, appMapDir?: string): Promise<FindingStatusListItem[]>;
+}
+export default function scanner(reportAllFindings: boolean, configuration: Configuration, files: string[]): Promise<Scanner>;

package/built/cli/scan/singleScan.d.ts

@@ -0,0 +1,12 @@
+import Configuration from '../../configuration/types/configuration';
+declare type SingleScanOptions = {
+    appmapFile?: string | string[];
+    appmapDir?: string;
+    configuration: Configuration;
+    reportAllFindings: boolean;
+    reportFile: string;
+    appId?: string;
+    ide?: string;
+};
+export default function singleScan(options: SingleScanOptions): Promise<void>;
+export {};

package/built/cli/scan/ui/interactiveProgess.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import { AppMap, Event } from '@appland/models';
+import EventEmitter from 'events';
+import AppMapIndex from '../../../appMapIndex';
+import Check from '../../../check';
+import ProgressReporter from '../../../progressReporter';
+import { MatchResult } from '../../../types';
+import { ScopeName } from '../../../index';
+import { Breakpoint } from '../breakpoint';
+declare type ContextVariables = {
+    event?: Event;
+    matchResult?: string | boolean | MatchResult[];
+};
+export default class InteractiveProgress extends EventEmitter implements ProgressReporter {
+    breakpoints: Breakpoint[];
+    depth: number;
+    counter: number;
+    appMap?: AppMap;
+    appMapFileName?: string;
+    check?: Check;
+    scope?: Event;
+    event?: Event;
+    breakpointResolver?: () => void;
+    constructor();
+    initialize(): void;
+    addBreakpoint(breakpoint: Breakpoint): void;
+    removeBreakpoint(breakpoint: Breakpoint): void;
+    get prefix(): string;
+    resume(): void;
+    breakOn(eventName: string, variables: ContextVariables): Promise<void>;
+    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>;
+}
+export {};

package/built/cli/scan/ui/scanContext.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import Check from '../../../check';
+import RuleChecker from '../../../ruleChecker';
+import { Breakpoint } from '../breakpoint';
+import InteractiveProgress from './interactiveProgess';
+export default class ScanContext extends EventEmitter {
+    checks: Check[];
+    files: string[];
+    progress: InteractiveProgress;
+    checker: RuleChecker;
+    breakpoint?: Breakpoint;
+    isScanning: boolean;
+    constructor(checks: Check[], files: string[]);
+    scan(): void;
+    protected doScan(): Promise<void>;
+}

package/built/cli/scan/ui/state/addBreakpoint.d.ts

@@ -0,0 +1,3 @@
+import ScanContext from '../scanContext';
+import { State } from '../state';
+export default function addBreakpoint(context: ScanContext): Promise<State>;

package/built/cli/scan/ui/state/eval.d.ts

@@ -0,0 +1,3 @@
+import ScanContext from '../scanContext';
+import { State } from '../state';
+export default function initial(context: ScanContext): Promise<State | undefined>;

package/built/cli/scan/ui/state/hint.d.ts

@@ -0,0 +1,3 @@
+import ScanContext from '../scanContext';
+import { State } from '../state';
+export default function hint(_context: ScanContext): Promise<State>;

package/built/cli/scan/ui/state/hitBreakpoint.d.ts

@@ -0,0 +1,3 @@
+import ScanContext from '../scanContext';
+import { State } from '../state';
+export default function hitBreakpoint(context: ScanContext): Promise<State>;

package/built/cli/scan/ui/state/initial.d.ts

@@ -0,0 +1,3 @@
+import ScanContext from '../scanContext';
+import { State } from '../state';
+export default function initial(_context: ScanContext): Promise<State | undefined>;

package/built/cli/scan/ui/state/scan.d.ts

@@ -0,0 +1,3 @@
+import ScanContext from '../scanContext';
+import { State } from '../state';
+export default function scan(context: ScanContext): Promise<State>;

package/built/cli/scan/ui/state.d.ts

@@ -0,0 +1,2 @@
+import ScanContext from './scanContext';
+export declare type State = (context: ScanContext) => Promise<State | undefined>;

package/built/cli/scan/ui/userInteraction.d.ts

@@ -0,0 +1,18 @@
+import { Answers, QuestionCollection } from 'inquirer';
+interface SpinnerOptions {
+    supressSpinner?: boolean;
+}
+export declare class UserInteraction {
+    private spinner;
+    prompt(questions: QuestionCollection, opts?: SpinnerOptions): Promise<Answers>;
+    continue(msg: string): Promise<void>;
+    confirm(msg: string): Promise<boolean>;
+    progress(msg: string): void;
+    success(msg?: string, align?: 'center' | 'left' | 'right'): void;
+    error(msg?: unknown): void;
+    warn(msg?: string): void;
+    get status(): string;
+    set status(value: string);
+}
+declare const UI: UserInteraction;
+export default UI;

package/built/cli/scan/watchScan.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import * as chokidar from 'chokidar';
+import { TimestampedConfiguration } from '../../configuration/configurationProvider';
+import EventEmitter from 'events';
+export declare type WatchScanOptions = {
+    appId?: string;
+    appmapDir: string;
+    configFile: string;
+};
+declare module 'async' {
+    interface QueueObject<T> {
+        [Symbol.iterator](): Iterator<T>;
+    }
+}
+export declare class Watcher {
+    private options;
+    config?: TimestampedConfiguration;
+    appmapWatcher?: chokidar.FSWatcher;
+    appmapPoller?: chokidar.FSWatcher;
+    configWatcher?: chokidar.FSWatcher;
+    scanEventEmitter: EventEmitter;
+    constructor(options: WatchScanOptions);
+    watch(): Promise<void>;
+    isError(error: unknown, code: string): boolean;
+    watcherErrorFunction(error: Error): Promise<void>;
+    close(): Promise<void>;
+    private queue;
+    private processing;
+    protected enqueue(mtimePath: string): void;
+    protected scan(mtimePath: string): Promise<void>;
+    protected reloadConfig(): Promise<void>;
+}
+export default function watchScan(options: WatchScanOptions): Promise<void>;

package/built/cli/scan.d.ts

@@ -0,0 +1,9 @@
+import { Metadata } from '@appland/models';
+import Check from '../check';
+import { Finding } from '../index';
+declare type Result = {
+    appMapMetadata: Record<string, Metadata>;
+    findings: Finding[];
+};
+export default function scan(files: string[], checks: Check[], skipErrors?: boolean): Promise<Result>;
+export {};

package/built/cli/scanArgs.d.ts

@@ -0,0 +1,2 @@
+import { Argv } from 'yargs';
+export default function (args: Argv): void;

package/built/cli/scanOptions.d.ts

@@ -0,0 +1,9 @@
+export default interface ScanOptions {
+    app?: string;
+    apiKey?: string;
+    directory?: string;
+    appmapDir?: string;
+    config: string;
+    reportFile: string;
+    verbose?: boolean;
+}

package/built/cli/updateCommitStatus.d.ts

@@ -0,0 +1 @@
+export default function updateCommitStatus(numFindings: number, numChecks: number): Promise<void>;

package/built/cli/upload/command.d.ts

@@ -0,0 +1,8 @@
+import { Arguments, Argv } from 'yargs';
+declare const _default: {
+    command: string;
+    describe: string;
+    builder(args: Argv): Argv;
+    handler(options: Arguments): Promise<void>;
+};
+export default _default;

package/built/cli/upload/options.d.ts

@@ -0,0 +1,11 @@
+export default interface CommandOptions {
+    verbose?: boolean;
+    reportFile: string;
+    directory?: string;
+    appmapDir?: string;
+    app?: string;
+    mergeKey?: string;
+    branch?: string;
+    commit?: string;
+    environment?: string;
+}

package/built/cli/upload/pruneAppMap.d.ts

@@ -0,0 +1,4 @@
+import { AppMapBuilder } from '@appland/models';
+export declare function maxAppMapSize(): number;
+export declare function pruneAppMap(builder: AppMapBuilder, maxSize: number): AppMapBuilder;
+export declare function buildAppMap(appMapJson: Record<string, unknown>): AppMapBuilder;

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>;