@now/build-utils

const buildsSchema: {
    type: string;
    minItems: number;
    maxItems: number;
    items: {
        type: string;
        additionalProperties: boolean;
        required: string[];
        properties: {
            src: { type: string; minLength: number; maxLength: number };
            use: { type: string; minLength: number; maxLength: number };
            config: { type: string };
        };
    };
};

const functionsSchema: {
    type: string;
    minProperties: number;
    maxProperties: number;
    additionalProperties: boolean;
    patternProperties: {
        '^.{1,256}$': {
            type: string;
            additionalProperties: boolean;
            properties: {
                runtime: { type: string; maxLength: number };
                memory: { enum: number[] };
                maxDuration: { type: string; minimum: number; maximum: number };
                includeFiles: { type: string; maxLength: number };
                excludeFiles: { type: string; maxLength: number };
            };
        };
    };
};

const installDependencies: (
    destPath: string,
    args?: string[],
    spawnOpts?: SpawnOptions,
    meta?: Meta
) => Promise<void>;

createLambda: ({
    files,
    handler,
    runtime,
    memory,
    maxDuration,
    environment,
}: CreateLambdaOptions) => Promise<Lambda>;

debug: (message: string, ...additional: any[]) => void;

detectApiDirectory: (builders: Builder[]) => string | null;

detectApiExtensions: (builders: Builder[]) => Set<string>;

detectBuilders: (
    files: string[],
    pkg?: PackageJson | undefined | null,
    options?: Options
) => Promise<{
    builders: Builder[] | null;
    errors: ErrorResponse[] | null;
    warnings: ErrorResponse[];
    defaultRoutes: Route[] | null;
    redirectRoutes: Route[] | null;
    rewriteRoutes: Route[] | null;
    errorRoutes: Route[] | null;
}>;

detectFramework: ({
    fs,
    frameworkList,
}: DetectFrameworkOptions) => Promise<string | null>;

detectOutputDirectory: (builders: Builder[]) => string | null;

download: (
    files: Files,
    basePath: string,
    meta?: Meta
) => Promise<DownloadedFiles>;

execAsync: (
    command: string,
    args: string[],
    opts?: SpawnOptionsExtended
) => Promise<{ stdout: string; stderr: string; code: number }>;

execCommand: (command: string, options?: SpawnOptions) => Promise<boolean>;

getDiscontinuedNodeVersions: () => NodeVersion[];

getLambdaOptionsFromFunction: ({
    sourceFile,
    config,
}: GetLambdaOptionsFromFunctionOptions) => Promise<
    Pick<LambdaOptions, 'memory' | 'maxDuration'>
>;

getLatestNodeVersion: () => NodeVersion;

getNodeBinPath: ({ cwd }: { cwd: string }) => Promise<string>;

getNodeVersion: (
    destPath: string,
    _nodeVersion?: string,
    _config?: Config,
    meta?: Meta
) => Promise<NodeVersion>;

getPlatformEnv: (name: string) => string | undefined;

getPrettyError: (obj: {
    dataPath?: string;
    message?: string;
    params: any;
}) => NowBuildError;

getScriptName: (
    pkg: Pick<PackageJson, 'scripts'> | null | undefined,
    possibleNames: Iterable<string>
) => string | null;

getSpawnOptions: (meta: Meta, nodeVersion: NodeVersion) => SpawnOptions;

getWriteableDirectory: () => Promise<string>;

glob: (
    pattern: string,
    opts: GlobOptions | string,
    mountpoint?: string
) => Promise<FsFiles>;

isOfficialRuntime: (desired: string, name?: string | undefined) => boolean;

isStaticRuntime: (name?: string | undefined) => boolean;

isSymbolicLink: (mode: number) => boolean;

readConfigFile: <T>(files: string | string[]) => Promise<T | null>;

rename: (files: Files, delegate: Delegate) => Files;

runBundleInstall: (
    destPath: string,
    args?: string[],
    spawnOpts?: SpawnOptions,
    meta?: Meta
) => Promise<void>;

runNpmInstall: (
    destPath: string,
    args?: string[],
    spawnOpts?: SpawnOptions,
    meta?: Meta
) => Promise<void>;

runPackageJsonScript: (
    destPath: string,
    scriptNames: string | Iterable<string>,
    spawnOpts?: SpawnOptions
) => Promise<boolean>;

runPipInstall: (
    destPath: string,
    args?: string[],
    spawnOpts?: SpawnOptions,
    meta?: Meta
) => Promise<void>;

runShellScript: (
    fsPath: string,
    args?: string[],
    spawnOpts?: SpawnOptions
) => Promise<boolean>;

shouldServe: ({ entrypoint, files, requestPath }: ShouldServeOptions) => boolean;

spawnAsync: (
    command: string,
    args: string[],
    opts?: SpawnOptionsExtended
) => Promise<void>;

spawnCommand: (command: string, options?: SpawnOptions) => any;

streamToBuffer: (stream: NodeJS.ReadableStream) => Promise<Buffer>;

walkParentDirs: ({
    base,
    start,
    filename,
}: WalkParentDirsProps) => Promise<string | null>;

type GlobOptions = vanillaGlob_.IOptions;

type StartDevServerOptions = BuildOptions;

type StartDevServerResult = StartDevServerSuccess | null;