@netlify/config 20.13.1 → 20.14.0

package/lib/api/build_settings.d.ts

@@ -0,0 +1,11 @@
+export function addBuildSettings({ defaultConfig, baseRelDir, siteInfo: { build_settings: buildSettings, plugins }, }: {
+    defaultConfig: any;
+    baseRelDir: any;
+    siteInfo: {
+        build_settings: any;
+        plugins: any;
+    };
+}): {
+    defaultConfig: any;
+    baseRelDir: any;
+};

package/lib/api/client.d.ts

@@ -0,0 +1,9 @@
+export function getApiClient({ token, offline, testOpts, host, scheme, pathPrefix }: {
+    token: any;
+    offline: any;
+    testOpts?: {} | undefined;
+    host: any;
+    scheme: any;
+    pathPrefix: any;
+}): NetlifyAPI | undefined;
+import { NetlifyAPI } from 'netlify';

package/lib/api/integrations.d.ts

@@ -0,0 +1,12 @@
+import { TestOptions } from '../types/options.js';
+type AvailableIntegration = {
+    slug: string;
+    hostSiteUrl: string;
+    hasBuild?: boolean;
+};
+type GetAvailableIntegrationsOpts = {
+    testOpts: TestOptions;
+    offline: boolean;
+};
+export declare const getAvailableIntegrations: ({ testOpts, offline, }: GetAvailableIntegrationsOpts) => Promise<AvailableIntegration[]>;
+export {};

package/lib/api/site_info.d.ts

@@ -0,0 +1,28 @@
+import { NetlifyAPI } from 'netlify';
+import { ModeOption, TestOptions } from '../types/options.js';
+type GetSiteInfoOpts = {
+    siteId: string;
+    mode: ModeOption;
+    siteFeatureFlagPrefix: string;
+    offline?: boolean;
+    api?: NetlifyAPI;
+    context?: string;
+    featureFlags?: Record<string, boolean>;
+    testOpts?: TestOptions;
+};
+/**
+ * Retrieve Netlify Site information, if available.
+ * Used to retrieve local build environment variables and UI build settings.
+ * This is not used in production builds since the buildbot passes this
+ * information instead.
+ * Requires knowing the `siteId` and having the access `token`.
+ * Silently ignore API errors. For example the network connection might be down,
+ * but local builds should still work regardless.
+ */
+export declare const getSiteInfo: ({ api, siteId, mode, siteFeatureFlagPrefix, context, offline, testOpts, }: GetSiteInfoOpts) => Promise<{
+    siteInfo: any;
+    accounts: any;
+    addons: any;
+    integrations: any;
+}>;
+export {};

package/lib/api/site_info.js

@@ -13,37 +13,18 @@ import { ERROR_CALL_TO_ACTION } from '../log/messages.js';
  */
 export const getSiteInfo = async function ({ api, siteId, mode, siteFeatureFlagPrefix, context, offline = false, testOpts = {}, }) {
     const { env: testEnv = false } = testOpts;
-    if (api === undefined || testEnv || offline) {
+    if (api === undefined || mode === 'buildbot' || testEnv) {
         const siteInfo = siteId === undefined ? {} : { id: siteId };
-        return { siteInfo, accounts: [], addons: [], integrations: [] };
-    }
-    const siteInfo = await getSite(api, siteId, siteFeatureFlagPrefix);
-    const featureFlags = siteInfo.feature_flags;
-    const useV2Endpoint = featureFlags?.cli_integration_installations_meta;
-    if (useV2Endpoint) {
-        const promises = [
-            getAccounts(api),
-            getAddons(api, siteId),
-            getIntegrations({ siteId, testOpts, offline, accountId: siteInfo.account_id, featureFlags }),
-        ];
-        const [accounts, addons, integrations] = await Promise.all(promises);
-        if (siteInfo.use_envelope) {
-            const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId, context });
-            siteInfo.build_settings.env = envelope;
-        }
-        return { siteInfo, accounts, addons, integrations };
-    }
-    if (mode === 'buildbot') {
-        const siteInfo = siteId === undefined ? {} : { id: siteId };
-        const integrations = await getIntegrations({ siteId, testOpts, offline, featureFlags });
+        const integrations = mode === 'buildbot' && !offline ? await getIntegrations({ siteId, testOpts, offline }) : [];
         return { siteInfo, accounts: [], addons: [], integrations };
     }
     const promises = [
+        getSite(api, siteId, siteFeatureFlagPrefix),
         getAccounts(api),
         getAddons(api, siteId),
-        getIntegrations({ siteId, testOpts, offline, featureFlags }),
+        getIntegrations({ siteId, testOpts, offline }),
     ];
-    const [accounts, addons, integrations] = await Promise.all(promises);
+    const [siteInfo, accounts, addons, integrations] = await Promise.all(promises);
     if (siteInfo.use_envelope) {
         const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId, context });
         siteInfo.build_settings.env = envelope;
@@ -59,7 +40,7 @@ const getSite = async function (api, siteId, siteFeatureFlagPrefix = null) {
         return { ...site, id: siteId };
     }
     catch (error) {
-        return throwUserError(`Failed retrieving site data for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
+        throwUserError(`Failed retrieving site data for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
     }
 };
 const getAccounts = async function (api) {
@@ -68,7 +49,7 @@ const getAccounts = async function (api) {
         return Array.isArray(accounts) ? accounts : [];
     }
     catch (error) {
-        return throwUserError(`Failed retrieving user account: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
+        throwUserError(`Failed retrieving user account: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
     }
 };
 const getAddons = async function (api, siteId) {
@@ -80,28 +61,22 @@ const getAddons = async function (api, siteId) {
         return Array.isArray(addons) ? addons : [];
     }
     catch (error) {
-        return throwUserError(`Failed retrieving addons for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
+        throwUserError(`Failed retrieving addons for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
     }
 };
-const getIntegrations = async function ({ siteId, accountId, testOpts, offline, featureFlags, }) {
+const getIntegrations = async function ({ siteId, testOpts, offline, }) {
     if (!siteId || offline) {
         return [];
     }
     const { host } = testOpts;
     const baseUrl = new URL(host ? `http://${host}` : `https://api.netlifysdk.com`);
-    const useV2Endpoint = featureFlags?.cli_integration_installations_meta;
-    const url = useV2Endpoint
-        ? `${baseUrl}team/${accountId}/integrations/installations/meta`
-        : `${baseUrl}site/${siteId}/integrations/safe`;
     try {
-        const response = await fetch(url);
+        const response = await fetch(`${baseUrl}site/${siteId}/integrations/safe`);
         const integrations = await response.json();
         return Array.isArray(integrations) ? integrations : [];
     }
     catch (error) {
-        // Integrations should not block the build if they fail to load
-        // TODO: We should consider blocking the build as integrations are a critical part of the build process
-        // https://linear.app/netlify/issue/CT-1214/implement-strategy-in-builds-to-deal-with-integrations-that-we-fail-to
+        // for now, we'll just ignore errors, as this is early days
         return [];
     }
 };

package/lib/base.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Retrieve the first `base` directory used to load the first config file.
+ */
+export declare const getInitialBase: ({ repositoryRoot, defaultConfig: { build: { base: defaultBase } }, inlineConfig: { build: { base: initialBase } }, }: {
+    repositoryRoot: any;
+    defaultConfig: {
+        build?: {
+            base: any;
+        } | undefined;
+    };
+    inlineConfig: {
+        build?: {
+            base?: any;
+        } | undefined;
+    };
+}) => string | undefined;
+/**
+ * Two config files can be used:
+ *  - The first one, using the `config` property or doing a default lookup
+ *    of `netlify.toml`
+ *  - If the first one has a `base` property pointing to a directory with
+ *    another `netlify.toml`, that second config file is used instead.
+ * This retrieves the final `base` directory used:
+ *  - To load the second config file
+ *  - As the `buildDir`
+ *  - To resolve file paths
+ * If the second file has a `base` property, it is ignored, i.e. it is not
+ * recursive.
+ */
+export declare const getBase: (base: string | undefined, repositoryRoot: string, config: $TSFixMe) => string | undefined;
+/**
+ * Also `config.build.base`.
+ */
+export declare const addBase: (config: any, base: any) => any;

package/lib/bin/flags.d.ts

@@ -0,0 +1,29 @@
+export declare const parseFlags: () => Partial<{
+    featureFlags: any;
+    config: unknown;
+    defaultConfig: any;
+    cachedConfig: any;
+    cachedConfigPath: unknown;
+    inlineConfig: any;
+    configMutations: any;
+    cwd: unknown;
+    packagePath: unknown;
+    repositoryRoot: unknown;
+    output: unknown;
+    stable: boolean;
+    token: unknown;
+    host: unknown;
+    scheme: unknown;
+    pathPrefix: unknown;
+    siteId: unknown;
+    context: unknown;
+    branch: unknown;
+    baseRelDir: unknown;
+    mode: unknown;
+    debug: unknown;
+    testOpts: unknown;
+    offline: unknown;
+    buffer: unknown;
+    _: (string | number)[];
+    $0: string;
+}>;

package/lib/bin/main.d.ts

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

package/lib/build_dir.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Retrieve the build directory used to resolve most paths.
+ * This is (in priority order):
+ *  - `build.base`
+ *  - `--repositoryRoot`
+ *  - the current directory (default value of `--repositoryRoot`)
+ */
+export declare const getBuildDir: (repositoryRoot: string, base?: string) => Promise<string>;

package/lib/cached_config.d.ts

@@ -0,0 +1,6 @@
+export function getCachedConfig({ cachedConfig, cachedConfigPath, token, api }: {
+    cachedConfig: any;
+    cachedConfigPath: any;
+    token: any;
+    api: any;
+}): Promise<any>;

package/lib/case.d.ts

@@ -0,0 +1,16 @@
+export function normalizeConfigCase({ Build, build, ...config }: {
+    [x: string]: any;
+    Build: any;
+    build?: any;
+}): {
+    build: {
+        base: any;
+        command: any;
+        edge_functions: any;
+        environment: any;
+        functions: any;
+        ignore: any;
+        processing: any;
+        publish: any;
+    };
+};

package/lib/context.d.ts

@@ -0,0 +1,9 @@
+export declare const normalizeContextProps: ({ config, config: { context: contextProps }, origin }: $TSFixMe) => any;
+export declare const mergeContext: ({ config: { context: contextProps, ...config }, config: { plugins }, context, branch, logs, }: $TSFixMe) => any;
+export declare const ensureConfigPriority: ({ build, ...config }: {
+    [x: string]: any;
+    build?: {} | undefined;
+}, context: any, branch: any) => {
+    context: any;
+    build: {};
+};

package/lib/default.d.ts

@@ -0,0 +1,11 @@
+export function parseDefaultConfig({ defaultConfig, base, baseRelDir, siteInfo, logs, debug }: {
+    defaultConfig: any;
+    base: any;
+    baseRelDir: any;
+    siteInfo: any;
+    logs: any;
+    debug: any;
+}): {
+    defaultConfig: any;
+    baseRelDir: any;
+};

package/lib/edge_functions.d.ts

@@ -0,0 +1,31 @@
+export declare const validations: ({
+    example: () => {
+        edge_functions: {
+            path: string;
+            function: string;
+        }[];
+    };
+    check: (value: any) => boolean;
+    message: string;
+    property: string;
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        edge_functions: {
+            pattern: string;
+            function: string;
+        }[];
+    };
+} | {
+    property: string;
+    check: (pathName: any) => any;
+    message: string;
+    example: () => {
+        edge_functions: {
+            path: string;
+            function: string;
+        }[];
+    };
+})[];

package/lib/env/envelope.d.ts

@@ -0,0 +1,7 @@
+import type { NetlifyAPI } from 'netlify';
+export declare const getEnvelope: ({ api, accountId, siteId, context, }: {
+    api: NetlifyAPI;
+    accountId: string;
+    siteId?: string;
+    context?: string;
+}) => Promise<any>;

package/lib/env/git.d.ts

@@ -0,0 +1 @@
+export function getGitEnv(buildDir: any, branch: any): Promise<Partial<any>>;

package/lib/env/main.d.ts

@@ -0,0 +1,13 @@
+export declare const getEnv: ({ api, mode, config, siteInfo, accounts, addons, buildDir, branch, deployId, buildId, context, }: {
+    api: any;
+    mode: any;
+    config: any;
+    siteInfo: any;
+    accounts: any;
+    addons: any;
+    buildDir: any;
+    branch: any;
+    deployId: any;
+    buildId: any;
+    context: any;
+}) => Promise<any>;

package/lib/error.d.ts

@@ -0,0 +1,2 @@
+export declare const throwUserError: (messageOrError: string | Error, error?: Error) => never;
+export declare const isUserError: (error: any) => boolean;

package/lib/events.d.ts

@@ -0,0 +1,2 @@
+export const EVENTS: string[];
+export const DEV_EVENTS: string[];

package/lib/files.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Make configuration paths relative to `buildDir` and converts them to
+ * absolute paths
+ */
+export declare const resolveConfigPaths: (options: {
+    config: $TSFixMe;
+    repositoryRoot: string;
+    buildDir: string;
+    baseRelDir?: boolean;
+    packagePath?: string;
+}) => object;
+export declare const resolvePath: (repositoryRoot: string, baseRel: string, originalPath: string, propName: string) => string | undefined;

package/lib/functions_config.d.ts

@@ -0,0 +1,26 @@
+export const bundlers: string[];
+export const WILDCARD_ALL: "*";
+export function normalizeFunctionsProps({ functions: v1FunctionsDirectory, ...build }: {
+    [x: string]: any;
+    functions: any;
+}, { [WILDCARD_ALL]: wildcardProps, ...functions }: {
+    [x: string]: any;
+    "*": any;
+}): {
+    build: {
+        [x: string]: any;
+    };
+    functions: {
+        "*": {
+            [x: string]: any;
+        };
+    };
+    functionsDirectoryProps: {
+        functionsDirectory: any;
+        functionsDirectoryOrigin: string;
+    } | {
+        functionsDirectory?: undefined;
+        functionsDirectoryOrigin?: undefined;
+    };
+};
+export const FUNCTION_CONFIG_PROPERTIES: Set<string>;

package/lib/headers.d.ts

@@ -0,0 +1,16 @@
+export function getHeadersPath({ build: { publish } }: {
+    build: {
+        publish: any;
+    };
+}): string;
+export function addHeaders({ config: { headers: configHeaders, ...config }, headersPath, logs, featureFlags, }: {
+    config: {
+        [x: string]: any;
+        headers: any;
+    };
+    headersPath: any;
+    logs: any;
+    featureFlags: any;
+}): Promise<{
+    headers: import("packages/headers-parser/lib/types.js").Header[];
+}>;

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { DEV_EVENTS, EVENTS } from './events.js';
+export { cleanupConfig } from './log/cleanup.js';
+export { resolveConfig } from './main.js';
+export { mergeConfigs } from './merge.js';
+export { applyMutations } from './mutations/apply.js';
+export { restoreConfig, updateConfig } from './mutations/update.js';

package/lib/inline_config.d.ts

@@ -0,0 +1,6 @@
+export function getInlineConfig({ inlineConfig, configMutations, logs, debug }: {
+    inlineConfig: any;
+    configMutations: any;
+    logs: any;
+    debug: any;
+}): any;

package/lib/integrations.d.ts

@@ -0,0 +1,18 @@
+import { IntegrationResponse } from './types/api.js';
+import { Integration } from './types/integrations.js';
+import { TestOptions } from './types/options.js';
+type MergeIntegrationsOpts = {
+    configIntegrations?: {
+        name: string;
+        dev?: {
+            path: string;
+            force_run_in_build?: boolean;
+        };
+    }[];
+    apiIntegrations: IntegrationResponse[];
+    context: string;
+    testOpts?: TestOptions;
+    offline: boolean;
+};
+export declare const mergeIntegrations: ({ configIntegrations, apiIntegrations, context, testOpts, offline, }: MergeIntegrationsOpts) => Promise<Integration[]>;
+export {};

package/lib/log/cleanup.d.ts

@@ -0,0 +1,22 @@
+export function cleanupConfig({ build: { base, command, commandOrigin, environment, edge_functions: edgeFunctions, ignore, processing, publish, publishOrigin, }, headers, headersOrigin, plugins, redirects, redirectsOrigin, baseRelDir, functions, functionsDirectory, }: {
+    build?: {
+        base: any;
+        command: any;
+        commandOrigin: any;
+        environment?: {} | undefined;
+        edge_functions: any;
+        ignore: any;
+        processing: any;
+        publish: any;
+        publishOrigin: any;
+    } | undefined;
+    headers: any;
+    headersOrigin: any;
+    plugins?: any[] | undefined;
+    redirects: any;
+    redirectsOrigin: any;
+    baseRelDir: any;
+    functions: any;
+    functionsDirectory: any;
+}): any;
+export function cleanupEnvironment(environment: any): string[];

package/lib/log/logger.d.ts

@@ -0,0 +1,13 @@
+export function logsAreBuffered(logs: any): boolean;
+export function getBufferLogs({ buffer }: {
+    buffer: any;
+}): {
+    stdout: never[];
+    stderr: never[];
+} | undefined;
+export function log(logs: any, string: any, { color }?: {
+    color: any;
+}): void;
+export function logWarning(logs: any, string: any, opts: any): void;
+export function logObject(logs: any, object: any, opts: any): void;
+export function logSubHeader(logs: any, string: any, opts: any): void;

package/lib/log/main.d.ts

@@ -0,0 +1,26 @@
+export function logOpts(opts: any, { logs, debug, cachedConfig, cachedConfigPath }: {
+    logs: any;
+    debug: any;
+    cachedConfig: any;
+    cachedConfigPath: any;
+}): void;
+export function logDefaultConfig(defaultConfig: any, { logs, debug, baseRelDir }: {
+    logs: any;
+    debug: any;
+    baseRelDir: any;
+}): void;
+export function logInlineConfig(initialConfig: any, { logs, debug }: {
+    logs: any;
+    debug: any;
+}): void;
+export function logResult({ configPath, buildDir, config, context, branch, env }: {
+    configPath: any;
+    buildDir: any;
+    config: any;
+    context: any;
+    branch: any;
+    env: any;
+}, { logs, debug }: {
+    logs: any;
+    debug: any;
+}): void;

package/lib/log/messages.d.ts

@@ -0,0 +1,11 @@
+export const ERROR_CALL_TO_ACTION: "Double-check your login status with 'netlify status' or contact support with details of your error.";
+export function throwOnInvalidTomlSequence(invalidSequence: any): void;
+export function warnLegacyFunctionsDirectory({ config, logs }: {
+    config?: {} | undefined;
+    logs: any;
+}): void;
+export function warnContextPluginConfig(logs: any, packageName: any, context: any): void;
+export function throwContextPluginsConfig(packageName: any, context: any): void;
+export function warnHeadersParsing(logs: any, errors: any): void;
+export function warnHeadersCaseSensitivity(logs: any, headers: any): void;
+export function warnRedirectsParsing(logs: any, errors: any): void;

package/lib/log/options.d.ts

@@ -0,0 +1,12 @@
+export function cleanupConfigOpts({ config, cwd, context, branch, mode, repositoryRoot, siteId, baseRelDir, env, featureFlags, }: {
+    config: any;
+    cwd: any;
+    context: any;
+    branch: any;
+    mode: any;
+    repositoryRoot: any;
+    siteId: any;
+    baseRelDir: any;
+    env?: {} | undefined;
+    featureFlags?: {} | undefined;
+}): Partial<any>;

package/lib/log/serialize.d.ts

@@ -0,0 +1 @@
+export function serializeObject(object: any): any;

package/lib/log/theme.d.ts

@@ -0,0 +1,6 @@
+export namespace THEME {
+    let subHeader: import("chalk").ChalkInstance;
+    let errorSubHeader: import("chalk").ChalkInstance;
+    let warningLine: import("chalk").ChalkInstance;
+    let highlightWords: import("chalk").ChalkInstance;
+}

package/lib/main.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Load the configuration file.
+ * Takes an optional configuration file path as input and return the resolved
+ * `config` together with related properties such as the `configPath`.
+ */
+export declare const resolveConfig: (opts: any) => Promise<any>;

package/lib/main.js

@@ -39,6 +39,7 @@ export const resolveConfig = async function (opts) {
         mode,
         offline,
         siteFeatureFlagPrefix,
+        featureFlags,
         testOpts,
     });
     const { defaultConfig: defaultConfigA, baseRelDir: baseRelDirA } = parseDefaultConfig({

package/lib/merge.d.ts

@@ -0,0 +1,3 @@
+export function mergeConfigs(configs: any, { concatenateArrays }?: {
+    concatenateArrays: any;
+}): object;

package/lib/merge_normalize.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Perform validation and normalization logic to apply to all of:
+ *  - config, defaultConfig, inlineConfig
+ *  - context-specific configs
+ * Therefore, this is performing before merging those together.
+ */
+export declare const normalizeBeforeConfigMerge: (config: $TSFixMe, origin: any) => any;
+/**
+ * Validation and normalization logic performed after merging
+ */
+export declare const normalizeAfterConfigMerge: (config: $TSFixMe, packagePath?: string) => any;

package/lib/mutations/apply.d.ts

@@ -0,0 +1 @@
+export function applyMutations(inlineConfig: any, configMutations: any): any;

package/lib/mutations/apply.js

@@ -65,4 +65,7 @@ const MUTABLE_PROPS = {
     images: { lastEvent: 'onPostBuild' },
     'images.remote_images': { lastEvent: 'onPostBuild' },
     redirects: { lastEvent: 'onPostBuild' },
+    'dev.processing': { lastEvent: 'onPreDev' },
+    'dev.processing.html': { lastEvent: 'onPreDev' },
+    'dev.processing.html.injections': { lastEvent: 'onPreDev' },
 };

package/lib/mutations/config_prop_name.d.ts

@@ -0,0 +1,2 @@
+/** Retrieve normalized property name */
+export declare const getPropName: (keys: string[]) => string;

package/lib/mutations/update.d.ts

@@ -0,0 +1,17 @@
+export function updateConfig(configMutations: any, { buildDir, configPath, headersPath, outputConfigPath, redirectsPath, context, branch, logs, featureFlags, }: {
+    buildDir: any;
+    configPath: any;
+    headersPath: any;
+    outputConfigPath?: any;
+    redirectsPath: any;
+    context: any;
+    branch: any;
+    logs: any;
+    featureFlags: any;
+}): Promise<void>;
+export function restoreConfig(configMutations: any, { buildDir, configPath, headersPath, redirectsPath }: {
+    buildDir: any;
+    configPath: any;
+    headersPath: any;
+    redirectsPath: any;
+}): Promise<void>;

package/lib/normalize.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Normalize configuration object
+ */
+export declare const normalizeConfig: (config: $TSFixMe, packagePath?: string) => any;

package/lib/options/base.d.ts

@@ -0,0 +1,10 @@
+export function getBaseOverride({ repositoryRoot, cwd }: {
+    repositoryRoot: any;
+    cwd: any;
+}): Promise<{
+    base?: undefined;
+    baseRelDir?: undefined;
+} | {
+    base: string;
+    baseRelDir: boolean;
+}>;

package/lib/options/branch.d.ts

@@ -0,0 +1,4 @@
+export function getBranch({ branch, repositoryRoot }: {
+    branch: any;
+    repositoryRoot: any;
+}): Promise<any>;

package/lib/options/feature_flags.d.ts

@@ -0,0 +1,2 @@
+export function normalizeCliFeatureFlags(cliFeatureFlags: any): any;
+export const DEFAULT_FEATURE_FLAGS: {};

package/lib/options/main.d.ts

@@ -0,0 +1,7 @@
+export function addDefaultOpts(opts?: {}): {
+    logs: {
+        stdout: never[];
+        stderr: never[];
+    } | undefined;
+};
+export function normalizeOpts(opts: any): Promise<any>;

package/lib/options/repository_root.d.ts

@@ -0,0 +1,4 @@
+export function getRepositoryRoot({ repositoryRoot, cwd }: {
+    repositoryRoot: any;
+    cwd: any;
+}): Promise<any>;

package/lib/origin.d.ts

@@ -0,0 +1,10 @@
+export const UI_ORIGIN: "ui";
+export const CONFIG_ORIGIN: "config";
+export const DEFAULT_ORIGIN: "default";
+export const INLINE_ORIGIN: "inline";
+export function addOrigins(config: any, origin: any): {
+    redirects: any;
+} | {
+    redirectsOrigin: any;
+    redirects: any;
+};

package/lib/parse.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Load the configuration file and parse it (TOML)
+ * @param configPath The path to the toml file
+ * @returns
+ */
+export declare const parseConfig: (configPath?: string) => Promise<any>;
+/**
+ * Same but `configPath` is required and `configPath` might point to a
+ * non-existing file.
+ */
+export declare const parseOptionalConfig: (configPath: any) => Promise<any>;

package/lib/path.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Configuration location can be:
+ * - a local path with the --config CLI flag
+ * - a `netlify.*` file in the `repositoryRoot/{base}/{packagePath}`
+ * - a `netlify.*` file in the `repositoryRoot/{base}`
+ * - a `netlify.*` file in the `repositoryRoot`
+ * - a `netlify.*` file in the current directory or any parent
+ */
+export declare const getConfigPath: ({ configOpt, cwd, repositoryRoot, configBase, packagePath, }: {
+    cwd: string;
+    repositoryRoot: string;
+    configBase;
+    configOpt?: string;
+    packagePath?: string;
+}) => Promise<string | undefined>;

package/lib/redirects.d.ts

@@ -0,0 +1,10 @@
+export declare const getRedirectsPath: ({ build: { publish } }: $TSFixMe) => string;
+/**
+ * Add `config.redirects`
+ */
+export declare const addRedirects: ({ config: { redirects: configRedirects, ...config }, redirectsPath, logs, }: {
+    config: $TSFixMe;
+    redirectsPath: string;
+    logs: $TSFixMe;
+    featureFlags?: $TSFixMe;
+}) => Promise<any>;

package/lib/simplify.d.ts

@@ -0,0 +1,24 @@
+export function simplifyConfig({ build: { environment, processing: { css, html, images, js, ...processing }, services, ...build }, functions, plugins, headers, redirects, context, ...config }: {
+    [x: string]: any;
+    build?: {
+        environment: any;
+        processing?: {
+            css: any;
+            html: any;
+            images: any;
+            js: any;
+        } | undefined;
+        services: any;
+    } | undefined;
+    functions: any;
+    plugins: any;
+    headers: any;
+    redirects: any;
+    context?: {} | undefined;
+}): any;
+export function removeEmptyObject(object: any, propName: any): {
+    [x: number]: Partial<any>;
+};
+export function removeEmptyArray(array: any, propName: any): {
+    [x: number]: any[];
+};

package/lib/types/api.d.ts

@@ -0,0 +1,5 @@
+export type IntegrationResponse = {
+    slug: string;
+    version: string;
+    has_build: boolean;
+};

package/lib/types/integrations.d.ts

@@ -0,0 +1,8 @@
+export type Integration = {
+    slug: string;
+    version?: string;
+    has_build?: boolean;
+    dev?: {
+        path: string;
+    };
+};

package/lib/types/options.d.ts

@@ -0,0 +1,5 @@
+export type ModeOption = 'buildbot' | 'cli' | 'require';
+export type TestOptions = {
+    env?: boolean;
+    host?: string;
+};

package/lib/utils/group.d.ts

@@ -0,0 +1 @@
+export function groupBy(objects: any, keyName: any): any[];

package/lib/utils/remove_falsy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Remove falsy values from object
+ */
+export declare const removeFalsy: (obj: any) => Partial<any>;
+type NoUndefinedField<T> = {
+    [P in keyof T]: Exclude<T[P], null | undefined>;
+};
+export declare const removeUndefined: <T extends object>(obj: T) => NoUndefinedField<T>;
+export declare const isTruthy: <T>(value: T | false | undefined | null | '' | ' ') => value is T;
+export declare const isDefined: <T>(value: T | undefined | null) => value is T;
+export {};

package/lib/utils/set.d.ts

@@ -0,0 +1 @@
+export function setProp(parent: any, keys: any, value: any): any;

package/lib/utils/toml.d.ts

@@ -0,0 +1,2 @@
+export function parseToml(configString: any): any;
+export function serializeToml(object: any): any;

package/lib/validate/context.d.ts

@@ -0,0 +1,6 @@
+export function validateContextsPluginsConfig({ contextProps, plugins, contexts, logs }: {
+    contextProps: any;
+    plugins: any;
+    contexts: any;
+    logs: any;
+}): void;

package/lib/validate/example.d.ts

@@ -0,0 +1,7 @@
+export function getExample({ value, key, prevPath, example, formatInvalid }: {
+    value: any;
+    key: any;
+    prevPath: any;
+    example: any;
+    formatInvalid: any;
+}): string;

package/lib/validate/helpers.d.ts

@@ -0,0 +1,17 @@
+export function isArrayOfObjects(value: any): boolean;
+export function isArrayOfStrings(value: any): boolean;
+export function isString(value: any): boolean;
+export function validProperties(propNames: any, legacyPropNames: any): {
+    check: (value: any) => boolean;
+    message: string;
+};
+export namespace functionsDirectoryCheck {
+    function formatInvalid({ functionsDirectory }?: {
+        functionsDirectory: any;
+    }): {
+        functions: {
+            directory: any;
+        };
+    };
+    let propertyName: string;
+}

package/lib/validate/identical.d.ts

@@ -0,0 +1,3 @@
+export function validateIdenticalPlugins({ plugins }: {
+    plugins?: any[] | undefined;
+}): void;

package/lib/validate/main.d.ts

@@ -0,0 +1,5 @@
+export function validatePreCaseNormalize(config: any): void;
+export function validatePreMergeConfig(config: any): void;
+export function validatePreContextConfig(config: any): void;
+export function validatePreNormalizeConfig(config: any): void;
+export function validatePostNormalizeConfig(config: any): void;

package/lib/validate/validations.d.ts

@@ -0,0 +1,280 @@
+export const PRE_CASE_NORMALIZE_VALIDATIONS: {
+    property: string;
+    check: typeof isPlainObj;
+    message: string;
+    example: () => {
+        build: {
+            command: string;
+        };
+    };
+}[];
+export const PRE_MERGE_VALIDATIONS: ({
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        build: {
+            command: string;
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        plugins: {
+            package: string;
+        }[];
+    };
+})[];
+export const PRE_CONTEXT_VALIDATIONS: ({
+    property: string;
+    check: typeof isPlainObj;
+    message: string;
+    example: () => {
+        context: {
+            production: {
+                publish: string;
+            };
+        };
+    };
+} | {
+    property: string;
+    check: typeof isPlainObj;
+    message: string;
+    example: (contextProps: any, key: any) => {
+        context: {
+            [x: number]: {
+                publish: string;
+            };
+        };
+    };
+})[];
+export const PRE_NORMALIZE_VALIDATIONS: ({
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        build: {
+            command: string;
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        plugins: {
+            package: string;
+        }[];
+    };
+} | {
+    property: string;
+    check: typeof isPlainObj;
+    message: string;
+    example: () => {
+        functions: {
+            external_node_modules: string[];
+        };
+    };
+} | {
+    property: string;
+    check: typeof isPlainObj;
+    message: string;
+    example: () => {
+        functions: {
+            ignored_node_modules: string[];
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        edge_functions: {
+            path: string;
+            function: string;
+        }[];
+    };
+})[];
+export const POST_NORMALIZE_VALIDATIONS: ({
+    example: () => {
+        edge_functions: {
+            path: string;
+            function: string;
+        }[];
+    };
+    check: (value: any) => boolean;
+    message: string;
+    property: string;
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        edge_functions: {
+            pattern: string;
+            function: string;
+        }[];
+    };
+} | {
+    property: string;
+    check: (pathName: any) => any;
+    message: string;
+    example: () => {
+        edge_functions: {
+            path: string;
+            function: string;
+        }[];
+    };
+} | {
+    example: {
+        plugins: {
+            package: string;
+            inputs: {
+                port: number;
+            };
+        }[];
+    };
+    check: (value: any) => boolean;
+    message: string;
+    property: string;
+} | {
+    property: string;
+    check: (packageName: any) => any;
+    message: string;
+    example: () => {
+        plugins: {
+            package: string;
+        }[];
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        build: {
+            base: string;
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        build: {
+            publish: string;
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        build: {
+            functions: string;
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: () => {
+        build: {
+            edge_functions: string;
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: (value: any, key: any, prevPath: any) => {
+        functions: {
+            [x: number]: {
+                deno_import_map: string;
+            };
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: (value: any, key: any, prevPath: any) => {
+        functions: {
+            [x: number]: {
+                external_node_modules: string[];
+            };
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: (value: any, key: any, prevPath: any) => {
+        functions: {
+            [x: number]: {
+                ignored_node_modules: string[];
+            };
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: (value: any, key: any, prevPath: any) => {
+        functions: {
+            [x: number]: {
+                included_files: string[];
+            };
+        };
+    };
+} | {
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+    example: (value: any, key: any, prevPath: any) => {
+        functions: {
+            [x: number]: {
+                node_bundler: string;
+            };
+        };
+    };
+} | {
+    property: string;
+    check: (value: any, key: any, prevPath: any) => boolean;
+    message: string;
+    example: () => {
+        functions: {
+            directory: string;
+        };
+    };
+} | {
+    property: string;
+    check: (cron: string) => boolean;
+    message: string;
+    example: (value: any, key: any, prevPath: any) => {
+        functions: {
+            [x: number]: {
+                schedule: string;
+            };
+        };
+    };
+} | {
+    example: () => {
+        functions: {
+            directory: string;
+        };
+    };
+    formatInvalid: ({ functionsDirectory }?: {
+        functionsDirectory: any;
+    }) => {
+        functions: {
+            directory: any;
+        };
+    };
+    propertyName: string;
+    property: string;
+    check: (value: any) => boolean;
+    message: string;
+})[];
+import isPlainObj from 'is-plain-obj';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/config",
-  "version": "20.13.1",
+  "version": "20.14.0",
   "description": "Netlify config module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -11,7 +11,8 @@
   },
   "files": [
     "bin.js",
-    "lib/**/*.js"
+    "lib/**/*.js",
+    "lib/**/*.d.ts"
   ],
   "author": "Netlify Inc.",
   "contributors": [
@@ -94,5 +95,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "600d5f1a934b57f39746083cce925ecfe9025fad"
+  "gitHead": "7289364df0eeacbb579acf11424a2299bd28ee32"
 }