@netlify/build 29.20.6 → 29.20.8

package/lib/plugins/child/utils.d.ts

@@ -0,0 +1,32 @@
+export function getUtils({ event, constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, CACHE_DIR }, runState, }: {
+    event: any;
+    constants: {
+        FUNCTIONS_SRC: any;
+        INTERNAL_FUNCTIONS_SRC: any;
+        CACHE_DIR: any;
+    };
+    runState: any;
+}): {
+    build: {
+        failPlugin: (message: any, opts: any) => never;
+        failBuild: any;
+        cancelBuild: any;
+    };
+    cache: {
+        save: (paths: any, optsA: any) => any;
+        restore: (paths: any, optsA: any) => any;
+        remove: (paths: any, optsA: any) => any;
+        has: (paths: any, optsA: any) => any;
+        list: (optsA: any) => Promise<string[]>;
+        getCacheDir: (optsA: any) => string;
+    };
+    run: (file: string, args?: object | string[] | undefined, options?: Record<string, unknown> | undefined) => import("execa").ExecaChildProcess<string>;
+    functions: {
+        add: (src: any) => Promise<void>;
+        list: any;
+        listAll: any;
+    };
+    status: {
+        show: any;
+    };
+};

package/lib/plugins/child/validate.d.ts

@@ -0,0 +1 @@
+export function validatePlugin(logic: any): void;

package/lib/plugins/compatibility.d.ts

@@ -0,0 +1,33 @@
+export function getExpectedVersion({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }: {
+    versions: any;
+    nodeVersion: any;
+    packageJson: any;
+    buildDir: any;
+    pinnedVersion: any;
+}): Promise<{
+    version: any;
+    compatWarning: string;
+}>;
+export namespace CONDITIONS {
+    namespace nodeVersion {
+        export { nodeVersionTest as test };
+        export { nodeVersionWarning as warning };
+    }
+    namespace siteDependencies {
+        export { siteDependenciesTest as test };
+        export { siteDependenciesWarning as warning };
+    }
+}
+declare function nodeVersionTest(allowedNodeVersion: any, { nodeVersion }: {
+    nodeVersion: any;
+}): boolean;
+declare function nodeVersionWarning(allowedNodeVersion: any): string;
+declare function siteDependenciesTest(allowedSiteDependencies: any, { packageJson: { devDependencies, dependencies }, buildDir }: {
+    packageJson: {
+        devDependencies: any;
+        dependencies: any;
+    };
+    buildDir: any;
+}): Promise<any>;
+declare function siteDependenciesWarning(allowedSiteDependencies: any): string;
+export {};

package/lib/plugins/error.d.ts

@@ -0,0 +1,4 @@
+export function failBuild(message: any, opts: any): never;
+export function failPlugin(message: any, opts: any): never;
+export function cancelBuild(message: any, opts: any): never;
+export function failPluginWithWarning(methodName: any, event: any, message: any, opts: any): void;

package/lib/plugins/events.d.ts

@@ -0,0 +1,5 @@
+export const isSoftFailEvent: any;
+export const runsAlsoOnBuildFailure: any;
+export const runsOnlyOnBuildFailure: any;
+export const runsAfterDeploy: any;
+export { DEV_EVENTS, EVENTS } from "@netlify/config";

package/lib/plugins/expected_version.d.ts

@@ -0,0 +1,10 @@
+export function addExpectedVersions({ pluginsOptions, autoPluginsDir, packageJson, debug, logs, buildDir, testOpts, featureFlags, }: {
+    pluginsOptions: any;
+    autoPluginsDir: any;
+    packageJson: any;
+    debug: any;
+    logs: any;
+    buildDir: any;
+    testOpts: any;
+    featureFlags: any;
+}): Promise<any>;

package/lib/plugins/internal.d.ts

@@ -0,0 +1 @@
+export declare const isNetlifyMaintainedPlugin: (pluginPackage: string) => boolean;

package/lib/plugins/ipc.d.ts

@@ -0,0 +1,10 @@
+export function callChild({ childProcess, eventName, payload, logs, verbose }: {
+    childProcess: any;
+    eventName: any;
+    payload: any;
+    logs: any;
+    verbose: any;
+}): Promise<any>;
+export function getEventFromChild(childProcess: any, callId: any): Promise<any>;
+export function getEventsFromParent(callback: any): Promise<any>;
+export function sendEventToParent(callId: any, payload: any, verbose: any, error: any): Promise<void>;

package/lib/plugins/list.d.ts

@@ -0,0 +1,9 @@
+export function getPluginsList({ debug, logs, testOpts: { pluginsListUrl } }: {
+    debug: any;
+    logs: any;
+    testOpts: {
+        pluginsListUrl: any;
+    };
+}): Promise<never[] | {
+    [k: string]: any;
+}>;

package/lib/plugins/load.d.ts

@@ -0,0 +1,9 @@
+export function loadPlugins({ pluginsOptions, childProcesses, packageJson, timers, logs, debug, verbose, }: {
+    pluginsOptions: any;
+    childProcesses: any;
+    packageJson: any;
+    timers: any;
+    logs: any;
+    debug: any;
+    verbose: any;
+}): Promise<any>;

package/lib/plugins/manifest/check.d.ts

@@ -0,0 +1,10 @@
+export function checkInputs({ inputs, manifest: { inputs: rules }, packageName, pluginPackageJson, loadedFrom, origin, }: {
+    inputs: any;
+    manifest: {
+        inputs?: any[] | undefined;
+    };
+    packageName: any;
+    pluginPackageJson: any;
+    loadedFrom: any;
+    origin: any;
+}): any;

package/lib/plugins/manifest/load.d.ts

@@ -0,0 +1,7 @@
+export function loadManifest({ manifestPath, packageName, pluginPackageJson, loadedFrom, origin }: {
+    manifestPath: any;
+    packageName: any;
+    pluginPackageJson: any;
+    loadedFrom: any;
+    origin: any;
+}): Promise<any>;

package/lib/plugins/manifest/main.d.ts

@@ -0,0 +1,18 @@
+import { PackageJson } from 'read-pkg-up';
+/**
+ * Load plugin's `manifest.yml`
+ */
+export declare const useManifest: ({ packageName, loadedFrom, origin, inputs, }: {
+    packageName: string;
+    loadedFrom?: unknown;
+    origin?: unknown;
+    inputs?: unknown;
+}, { pluginDir, packageDir, pluginPackageJson, pluginPackageJson: { version }, debug, }: {
+    pluginDir: string;
+    packageDir?: string | undefined;
+    pluginPackageJson: PackageJson;
+    debug: boolean;
+}) => Promise<{
+    manifest: any;
+    inputs: any;
+}>;

package/lib/plugins/manifest/path.d.ts

@@ -0,0 +1,5 @@
+export function getManifestPath({ pluginDir, packageDir, packageName }: {
+    pluginDir: any;
+    packageDir: any;
+    packageName: any;
+}): Promise<string | undefined>;

package/lib/plugins/manifest/validate.d.ts

@@ -0,0 +1 @@
+export function validateManifest(manifest: any, rawManifest: any): void;

package/lib/plugins/node_version.d.ts

@@ -0,0 +1,22 @@
+export type PluginsLoadedFrom = 'auto_install' | 'local' | 'package.json';
+export type PluginsOptions = {
+    packageName: string;
+    pluginPath?: any;
+    pinnedVersion?: any;
+    loadedFrom: PluginsLoadedFrom;
+    origin: 'config' | string;
+    inputs: Record<string, any>;
+};
+/**
+ * Local plugins and `package.json`-installed plugins use user's preferred Node.js version if higher than our minimum
+ * supported version. Else default to the system Node version.
+ * Local and programmatic builds use `@netlify/build` Node.js version, which is
+ * usually the system's Node.js version.
+ * If the user Node version does not satisfy our supported engine range use our own system Node version
+ */
+export declare const addPluginsNodeVersion: ({ pluginsOptions, nodePath, userNodeVersion, logs }: {
+    pluginsOptions: any;
+    nodePath: any;
+    userNodeVersion: any;
+    logs: any;
+}) => any;

package/lib/plugins/options.d.ts

@@ -0,0 +1,18 @@
+import { PackageJson } from 'read-pkg-up';
+export declare const getPluginsOptions: any;
+/**
+ * Retrieve information about @netlify/build when an error happens there and not
+ * in a plugin
+ */
+export declare const getSpawnInfo: () => {
+    plugin: {
+        packageName: string;
+        pluginPackageJson: PackageJson;
+    };
+    location: {
+        event: 'load';
+        packageName: string;
+        loadedFrom: 'core';
+        origin: 'core';
+    };
+};

package/lib/plugins/pinned_version.d.ts

@@ -0,0 +1,24 @@
+export function addPinnedVersions({ pluginsOptions, api, siteInfo: { id: siteId }, sendStatus }: {
+    pluginsOptions: any;
+    api: any;
+    siteInfo: {
+        id: any;
+    };
+    sendStatus: any;
+}): Promise<any>;
+export function pinPlugins({ pluginsOptions, failedPlugins, api, siteInfo: { id: siteId }, childEnv, mode, netlifyConfig, errorMonitor, logs, debug, testOpts, sendStatus, }: {
+    pluginsOptions: any;
+    failedPlugins: any;
+    api: any;
+    siteInfo: {
+        id: any;
+    };
+    childEnv: any;
+    mode: any;
+    netlifyConfig: any;
+    errorMonitor: any;
+    logs: any;
+    debug: any;
+    testOpts: any;
+    sendStatus: any;
+}): Promise<void>;

package/lib/plugins/resolve.d.ts

@@ -0,0 +1,17 @@
+export function resolvePluginsPath({ pluginsOptions, siteInfo, buildDir, packagePath, nodePath, packageJson, userNodeVersion, mode, api, logs, debug, sendStatus, testOpts, featureFlags, integrations, }: {
+    pluginsOptions: any;
+    siteInfo: any;
+    buildDir: any;
+    packagePath: any;
+    nodePath: any;
+    packageJson: any;
+    userNodeVersion: any;
+    mode: any;
+    api: any;
+    logs: any;
+    debug: any;
+    sendStatus: any;
+    testOpts: any;
+    featureFlags: any;
+    integrations: any;
+}): Promise<any[]>;

package/lib/plugins/spawn.d.ts

@@ -0,0 +1,2 @@
+export declare const startPlugins: any;
+export declare const stopPlugins: (childProcesses: any) => void;

package/lib/plugins_core/add.d.ts

@@ -0,0 +1,13 @@
+export function addCorePlugins({ netlifyConfig: { plugins }, constants }: {
+    netlifyConfig: {
+        plugins: any;
+    };
+    constants: any;
+}): {
+    packageName: any;
+    pluginPath: any;
+    pinnedVersion: any;
+    loadedFrom: any;
+    origin: any;
+    inputs: any;
+}[];

package/lib/plugins_core/build_command.d.ts

@@ -0,0 +1,36 @@
+export namespace buildCommandCore {
+    export let event: string;
+    export { coreStep };
+    export let coreStepId: string;
+    export let coreStepName: string;
+    export { coreStepDescription };
+    export { hasBuildCommand as condition };
+}
+declare function coreStep({ configPath, buildDir, nodePath, childEnv, logs, netlifyConfig: { build: { command: buildCommand, commandOrigin: buildCommandOrigin }, }, }: {
+    configPath: any;
+    buildDir: any;
+    nodePath: any;
+    childEnv: any;
+    logs: any;
+    netlifyConfig: {
+        build: {
+            command: any;
+            commandOrigin: any;
+        };
+    };
+}): Promise<{}>;
+declare function coreStepDescription({ netlifyConfig: { build: { commandOrigin: buildCommandOrigin }, }, }: {
+    netlifyConfig: {
+        build: {
+            commandOrigin: any;
+        };
+    };
+}): any;
+declare function hasBuildCommand({ netlifyConfig: { build: { command: buildCommand }, }, }: {
+    netlifyConfig: {
+        build: {
+            command: any;
+        };
+    };
+}): boolean;
+export {};

package/lib/plugins_core/deploy/buildbot_client.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+export function createBuildbotClient(buildbotServerSocket: any): net.Socket;
+export const connectBuildbotClient: (...args: any[]) => Promise<any>;
+export function closeBuildbotClient(client: any): Promise<void>;
+export function deploySiteWithBuildbotClient({ client, events, buildDir, repositoryRoot, constants }: {
+    client: any;
+    events: any;
+    buildDir: any;
+    repositoryRoot: any;
+    constants: any;
+}): Promise<undefined>;
+import net from 'net';

package/lib/plugins_core/deploy/index.d.ts

@@ -0,0 +1,30 @@
+export function shouldDeploy({ buildbotServerSocket }: {
+    buildbotServerSocket: any;
+}): boolean;
+export namespace deploySite {
+    export let event: string;
+    export { coreStep };
+    export let coreStepId: string;
+    export let coreStepName: string;
+    export function coreStepDescription(): string;
+    export { shouldDeploy as condition };
+}
+declare function coreStep({ buildDir, configPath, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, featureFlags, context, branch, configMutations, headersPath, redirectsPath, debug, saveConfig, }: {
+    buildDir: any;
+    configPath: any;
+    repositoryRoot: any;
+    packagePath: any;
+    constants: any;
+    buildbotServerSocket: any;
+    events: any;
+    logs: any;
+    featureFlags: any;
+    context: any;
+    branch: any;
+    configMutations: any;
+    headersPath: any;
+    redirectsPath: any;
+    debug: any;
+    saveConfig: any;
+}): Promise<{}>;
+export {};

package/lib/plugins_core/edge_functions/index.d.ts

@@ -0,0 +1,27 @@
+import { Metric } from '../../core/report_metrics.js';
+export declare const bundleEdgeFunctions: {
+    event: string;
+    coreStep: ({ buildDir, constants: { EDGE_FUNCTIONS_DIST: distDirectory, EDGE_FUNCTIONS_SRC: srcDirectory, INTERNAL_EDGE_FUNCTIONS_SRC: internalSrcDirectory, IS_LOCAL: isRunningLocally, }, debug, systemLog, featureFlags, logs, netlifyConfig, edgeFunctionsBootstrapURL, }: {
+        buildDir: string;
+        packagePath: string;
+        constants: Record<string, string>;
+        debug: boolean;
+        systemLog(...args: any[]): void;
+        featureFlags: Record<string, any>;
+        logs: any;
+        netlifyConfig: any;
+        edgeFunctionsBootstrapURL?: string | undefined;
+    }) => Promise<{
+        metrics: Metric[];
+    }>;
+    coreStepId: string;
+    coreStepName: string;
+    coreStepDescription: () => string;
+    condition: ({ buildDir, constants: { INTERNAL_EDGE_FUNCTIONS_SRC, EDGE_FUNCTIONS_SRC }, }: {
+        buildDir: any;
+        constants: {
+            INTERNAL_EDGE_FUNCTIONS_SRC: any;
+            EDGE_FUNCTIONS_SRC: any;
+        };
+    }) => Promise<boolean>;
+};

package/lib/plugins_core/edge_functions/lib/error.d.ts

@@ -0,0 +1 @@
+export function tagBundlingError(error: any): void;

package/lib/plugins_core/edge_functions/validate_manifest/validate_edge_functions_manifest.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureFlags } from '../../../core/feature_flags.js';
+export declare const validateEdgeFunctionsManifest: (manifest: any, featureFlags?: FeatureFlags) => Promise<{}>;

package/lib/plugins_core/functions/error.d.ts

@@ -0,0 +1 @@
+export function getZipError(error: any, functionsSrc: any): Promise<any>;

package/lib/plugins_core/functions/feature_flags.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureFlags } from '../../core/feature_flags.js';
+export declare const getZisiFeatureFlags: (featureFlags: FeatureFlags) => FeatureFlags;

package/lib/plugins_core/functions/index.d.ts

@@ -0,0 +1,53 @@
+import { NodeBundlerName } from '@netlify/zip-it-and-ship-it';
+export declare const bundleFunctions: {
+    event: string;
+    coreStep: ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, }: {
+        childEnv: any;
+        constants: {
+            INTERNAL_FUNCTIONS_SRC: any;
+            IS_LOCAL: any;
+            FUNCTIONS_SRC: any;
+            FUNCTIONS_DIST: any;
+        };
+        buildDir: any;
+        logs: any;
+        netlifyConfig: any;
+        featureFlags: any;
+        repositoryRoot: any;
+        userNodeVersion: any;
+        systemLog: any;
+    }) => Promise<{
+        tags?: undefined;
+        metrics?: undefined;
+    } | {
+        tags: {
+            bundler: NodeBundlerName[];
+        };
+        metrics: {
+            type: string;
+            name: string;
+            value: number;
+            tags: {
+                type: string;
+            };
+        }[];
+    }>;
+    coreStepId: string;
+    coreStepName: string;
+    coreStepDescription: () => string;
+    condition: ({ buildDir, constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC } }: {
+        buildDir: any;
+        constants: {
+            INTERNAL_FUNCTIONS_SRC: any;
+            FUNCTIONS_SRC: any;
+        };
+    }) => Promise<boolean>;
+};
+export declare const zipItAndShipIt: {
+    zipFunctions(args_0: string | string[], args_1: string, args_2?: import("@netlify/zip-it-and-ship-it").ZipFunctionsOptions | undefined): Promise<(Omit<import("@netlify/zip-it-and-ship-it/dist/function.js").FunctionArchive, "runtime"> & {
+        routes?: import("@netlify/zip-it-and-ship-it/dist/utils/routes.js").Route[] | undefined;
+        runtime: import("@netlify/zip-it-and-ship-it").RuntimeName;
+        schedule?: string | undefined;
+        runtimeAPIVersion?: number | undefined;
+    })[]>;
+};

package/lib/plugins_core/functions/utils.d.ts

@@ -0,0 +1,11 @@
+export function getUserAndInternalFunctions({ featureFlags, functionsSrc, functionsSrcExists, internalFunctionsSrc, internalFunctionsSrcExists, }: {
+    featureFlags: any;
+    functionsSrc: any;
+    functionsSrcExists: any;
+    internalFunctionsSrc: any;
+    internalFunctionsSrcExists: any;
+}): Promise<any[]>;
+export function validateFunctionsSrc({ functionsSrc, relativeFunctionsSrc }: {
+    functionsSrc: any;
+    relativeFunctionsSrc: any;
+}): Promise<boolean>;

package/lib/plugins_core/functions/zisi.d.ts

@@ -0,0 +1,22 @@
+import { FunctionConfig, ZipFunctionsOptions } from '@netlify/zip-it-and-ship-it';
+import type { FeatureFlags } from '../../core/feature_flags.js';
+type GetZisiParametersType = {
+    buildDir: string;
+    childEnv: Record<string, string>;
+    featureFlags: FeatureFlags;
+    functionsConfig: Record<string, any>;
+    functionsDist: string;
+    internalFunctionsSrc: string;
+    isRunningLocally: boolean;
+    repositoryRoot: string;
+    userNodeVersion: string;
+    systemLog: ZipFunctionsOptions['systemLog'];
+};
+export declare const getZisiParameters: ({ buildDir, childEnv, featureFlags, functionsConfig, functionsDist, internalFunctionsSrc, isRunningLocally, repositoryRoot, userNodeVersion, systemLog, }: GetZisiParametersType) => ZipFunctionsOptions;
+export declare const normalizeFunctionConfig: ({ buildDir, functionConfig, isRunningLocally, nodeVersion, }: {
+    buildDir: string;
+    functionConfig: Record<string, any>;
+    isRunningLocally: boolean;
+    nodeVersion: string | undefined;
+}) => FunctionConfig;
+export {};

package/lib/plugins_core/functions_install/index.d.ts

@@ -0,0 +1,6 @@
+export function onPreBuild({ constants: { FUNCTIONS_SRC, IS_LOCAL } }: {
+    constants: {
+        FUNCTIONS_SRC: any;
+        IS_LOCAL: any;
+    };
+}): Promise<{}>;

package/lib/plugins_core/list.d.ts

@@ -0,0 +1,8 @@
+export function listCorePlugins({ FUNCTIONS_SRC }: {
+    FUNCTIONS_SRC: any;
+}): ({
+    package: string;
+    pluginPath: string;
+    optional: boolean;
+} | undefined)[];
+export function isCorePlugin(packageName: any): boolean;

package/lib/plugins_core/save_artifacts/index.d.ts

@@ -0,0 +1,26 @@
+export namespace saveArtifacts {
+    export let event: string;
+    export { coreStep };
+    export let coreStepId: string;
+    export let coreStepName: string;
+    export function coreStepDescription(): string;
+    export { shouldSaveArtifacts as condition };
+}
+declare function coreStep({ buildDir, configPath, packagePath, outputConfigPath, repositoryRoot, logs, featureFlags, context, branch, configMutations, headersPath, redirectsPath, debug, saveConfig, }: {
+    buildDir: any;
+    configPath: any;
+    packagePath: any;
+    outputConfigPath: any;
+    repositoryRoot: any;
+    logs: any;
+    featureFlags: any;
+    context: any;
+    branch: any;
+    configMutations: any;
+    headersPath: any;
+    redirectsPath: any;
+    debug: any;
+    saveConfig: any;
+}): Promise<{}>;
+declare function shouldSaveArtifacts(options: any): boolean;
+export {};

package/lib/plugins_core/secrets_scanning/index.d.ts

@@ -0,0 +1,16 @@
+export declare const scanForSecrets: {
+    event: string;
+    coreStep: ({ buildDir, logs, netlifyConfig, explicitSecretKeys, systemLog }: {
+        buildDir: any;
+        logs: any;
+        netlifyConfig: any;
+        explicitSecretKeys: any;
+        systemLog: any;
+    }) => Promise<{}>;
+    coreStepId: string;
+    coreStepName: string;
+    coreStepDescription: () => string;
+    condition: ({ explicitSecretKeys }: {
+        explicitSecretKeys: any;
+    }) => boolean;
+};

package/lib/plugins_core/secrets_scanning/utils.d.ts

@@ -0,0 +1,67 @@
+export interface ScanResults {
+    matches: MatchResult[];
+    scannedFilesCount: number;
+}
+interface ScanArgs {
+    env: Record<string, unknown>;
+    keys: string[];
+    base: string;
+    filePaths: string[];
+}
+interface MatchResult {
+    lineNumber: number;
+    key: string;
+    file: string;
+}
+/**
+ * Determine if the user disabled scanning via env var
+ * @param env current envars
+ * @returns
+ */
+export declare function isSecretsScanningEnabled(env: Record<string, unknown>): boolean;
+/**
+ * given the explicit secret keys and env vars, return the list of secret keys which have non-empty or non-trivial values. This
+ * will also filter out keys passed in the SECRETS_SCAN_OMIT_KEYS env var.
+ *
+ * non-trivial values are values that are:
+ *  - >4 characters/digits
+ *  - not booleans
+ *
+ * @param env env vars list
+ * @param secretKeys
+ * @returns string[]
+ */
+export declare function getSecretKeysToScanFor(env: Record<string, unknown>, secretKeys: string[]): string[];
+/**
+ * Given the env and base directory, find all file paths to scan. It will look at the
+ * env vars to decide if it should omit certain paths.
+ *
+ * @param options
+ * @returns string[] of relative paths from base of files that should be searched
+ */
+export declare function getFilePathsToScan({ env, base }: {
+    env: any;
+    base: any;
+}): Promise<string[]>;
+/**
+ * Given the env vars, the current keys, paths, etc. Look across the provided files to find the values
+ * of the secrets based on the keys provided. It will process files separately in different read streams.
+ * The values that it looks for will be a unique set of plaintext, base64 encoded, and uri encoded permutations
+ * of each value - to catch common permutations that occur post build.
+ *
+ * @param scanArgs {ScanArgs} scan options
+ * @returns promise with all of the scan results, if any
+ */
+export declare function scanFilesForKeyValues({ env, keys, filePaths, base }: ScanArgs): Promise<ScanResults>;
+/**
+ * ScanResults are all of the finds for all keys and their disparate locations. Scanning is
+ * async in streams so order can change a lot. This function groups the results into an object
+ * where the keys are the env var keys and the values are all match results for that key
+ *
+ * @param scanResults
+ * @returns
+ */
+export declare function groupScanResultsByKey(scanResults: ScanResults): {
+    [key: string]: MatchResult[];
+};
+export {};

package/lib/report/statsd.d.ts

@@ -0,0 +1,29 @@
+import { StatsD } from 'hot-shots';
+export interface InputStatsDOptions {
+    host?: string;
+    port?: number;
+}
+export type StatsDOptions = Required<InputStatsDOptions>;
+export declare const validateStatsDOptions: (statsdOpts: InputStatsDOptions) => statsdOpts is Required<InputStatsDOptions>;
+/**
+ * Start a new StatsD Client and a new UDP socket
+ */
+export declare const startClient: (statsdOpts: StatsDOptions) => Promise<StatsD>;
+/**
+ * Close the StatsD Client
+ *
+ * UDP packets are buffered and flushed every 10 seconds and
+ * closing the client forces all buffered metrics to be flushed.
+ */
+export declare const closeClient: (client: StatsD) => Promise<void>;
+/**
+ * Make sure the timer name does not include special characters.
+ * For example, the `packageName` of local plugins includes dots.
+ */
+export declare const normalizeTagName: (name: string) => string;
+/**
+ * Formats and flattens the tags as array
+ * We do this because we might send the same tag with different values `{ tag: ['a', 'b'] }`
+ * which cannot be represented in an flattened object and `hot-shots` also supports tags as array in the format `['tag:a', 'tag:b']`
+ */
+export declare const formatTags: (tags: Record<string, string | string[]>) => string[];