@aventara/cli 0.0.0-stage → 0.1.0-pilot.0

package/dist/templates/prisma7/prisma7.templates.js

@@ -0,0 +1,396 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { lowestVersionOf } from "../../catalog/range.reader.js";
+/**
+ * The `prisma7` entry's templates (D7): Prisma 7 knowledge as text the CLI
+ * writes and reads, keyed by the providers `@aventara/prisma7-adapter`
+ * declares. Every value that is an adapter fact — the ORM package, the driver
+ * per provider, the generator, the generate bin, the version floor — is read
+ * from the catalog entry handed in, not restated here.
+ *
+ * The texts follow the Nest scaffold's formatting (prettier, `singleQuote`,
+ * `trailingComma: "all"`, B1), so the project's own `format` script leaves them
+ * as they are.
+ */
+/** The generated client goes under `src`, where `nest build` compiles it (B6). */
+const CLIENT_OUTPUT = "src/generated/prisma";
+const SCHEMA = "prisma/schema.prisma";
+/** B5: the Prisma CLI loads either name, and `prisma7.config.ts` wins when both exist. */
+const CONFIG_FILES = ["prisma7.config.ts", "prisma.config.ts"];
+const DRIVER_PREFIX = "@prisma/adapter-";
+const NEW_SERVICE = {
+    file: "src/prisma.service.ts",
+    exportName: "PrismaService",
+};
+const NEW_MODULE = {
+    file: "src/prisma.service.ts",
+    exportName: "PrismaModule",
+};
+const PROVIDERS = {
+    sqlite: {
+        driverClass: "PrismaBetterSqlite3",
+        driverOptions: "{ url }",
+        databaseUrl: "file:./dev.db",
+        gitignore: ["/dev.db*"],
+        // B9: pnpm 12 refuses these install scripts until they are allowed.
+        nativeBuilds: ["@prisma/engines", "better-sqlite3", "prisma"],
+    },
+    postgresql: {
+        driverClass: "PrismaPg",
+        driverOptions: "{ connectionString: url }",
+        // `prisma init`'s own placeholder (B5); printed in the next steps, never asked (Q16-8).
+        databaseUrl: "postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public",
+        gitignore: [],
+        nativeBuilds: ["@prisma/engines", "prisma"],
+    },
+};
+/** A relative import specifier from `from` (a project file) to `to` (a project path, no extension). */
+function specifier(from, to, js) {
+    const relative = path.posix.relative(path.posix.dirname(from), to);
+    return `${relative.startsWith(".") ? relative : `./${relative}`}${js}`;
+}
+function schema(input) {
+    return [
+        "generator client {",
+        `  provider = "${input.entry.generators[0]}"`,
+        `  output   = "../${CLIENT_OUTPUT}"`,
+        ...(input.moduleKind === "cjs" ? ['  moduleFormat = "cjs"'] : []),
+        "}",
+        "",
+        "datasource db {",
+        `  provider = "${input.provider}"`,
+        "}",
+        "",
+        // R12: Prisma's `--with-model` starter (B5).
+        "model User {",
+        "  id    Int     @id @default(autoincrement())",
+        "  email String  @unique",
+        "  name  String?",
+        "}",
+        "",
+    ].join("\n");
+}
+/** `prisma.config.ts` (Q16-19). Prisma does not load `.env` itself (B5). */
+function prismaConfig() {
+    return [
+        "import { existsSync } from 'node:fs';",
+        "import { defineConfig } from 'prisma/config';",
+        "",
+        "// Prisma reads DATABASE_URL from the environment and does not load .env itself.",
+        "if (existsSync('.env')) {",
+        "  process.loadEnvFile('.env');",
+        "}",
+        "",
+        "export default defineConfig({",
+        `  schema: '${SCHEMA}',`,
+        "  migrations: {",
+        "    path: 'prisma/migrations',",
+        "  },",
+        "  datasource: {",
+        "    url: process.env.DATABASE_URL,",
+        "  },",
+        "});",
+        "",
+    ].join("\n");
+}
+/** The developer-owned service (P2: `extends PrismaClient`, so `client: prisma`). */
+function prismaService(input) {
+    const provider = PROVIDERS[input.provider];
+    const driver = input.entry.drivers[input.provider];
+    return [
+        "import { Injectable, Module, type OnModuleDestroy } from '@nestjs/common';",
+        `import { ${provider.driverClass} } from '${driver}';`,
+        `import { PrismaClient } from '${specifier(NEW_SERVICE.file, `${input.clientOutput}/client`, input.js)}';`,
+        "",
+        "@Injectable()",
+        "export class PrismaService extends PrismaClient implements OnModuleDestroy {",
+        "  constructor() {",
+        "    const url = process.env.DATABASE_URL;",
+        "    if (!url) {",
+        "      // Thrown while Nest builds the application, before it listens.",
+        "      throw new Error(",
+        "        'DATABASE_URL is not set: put it in .env (the start scripts load it) or in the environment.',",
+        "      );",
+        "    }",
+        `    super({ adapter: new ${provider.driverClass}(${provider.driverOptions}) });`,
+        "  }",
+        "",
+        "  async onModuleDestroy(): Promise<void> {",
+        "    await this.$disconnect();",
+        "  }",
+        "}",
+        "",
+        "@Module({ providers: [PrismaService], exports: [PrismaService] })",
+        "export class PrismaModule {}",
+        "",
+    ].join("\n");
+}
+/** `src/aventara.config.ts` (R8, Q16-17): the framework's configuration. */
+function aventaraConfig(input) {
+    const file = "src/aventara.config.ts";
+    const service = input.service.exportName;
+    return [
+        `import { createPrismaAdapter } from '${input.entry.adapterPackage}';`,
+        `import { discovery } from '${specifier(file, input.artifact.replace(/\.ts$/, ""), input.js)}';`,
+        `import type { ${service} } from '${specifier(file, input.service.file.replace(/\.ts$/, ""), input.js)}';`,
+        "",
+        "/**",
+        " * Aventara's configuration: the entrypoint, and the restrictions and",
+        " * pipelines you add. AventaraModule (app.module.ts) builds the framework from",
+        " * it; `discovery` is regenerated by the aventara:prepare script.",
+        " */",
+        `export async function aventaraConfig(prisma: ${service}) {`,
+        "  return {",
+        "    entrypoint: '/api',",
+        "    adapter: await createPrismaAdapter({",
+        input.service.clientMember === undefined
+            ? "      client: prisma,"
+            : `      client: prisma.${input.service.clientMember},`,
+        "      discovery,",
+        `      provider: '${input.provider}',`,
+        `      driver: '${input.entry.drivers[input.provider]}',`,
+        "    }),",
+        "  } as const;",
+        "}",
+        "",
+    ].join("\n");
+}
+function prepare(input) {
+    return [
+        input.entry.bin,
+        `--schema ${input.schema}`,
+        `--client ${input.clientOutput}`,
+        `--provider ${input.provider}`,
+        `--driver ${input.entry.drivers[input.provider]}`,
+        `--out ${input.artifact}`,
+    ].join(" ");
+}
+function appModule(service, module, js) {
+    const from = "src/app.module.ts";
+    const sameFile = service.file === module.file;
+    return {
+        imports: [
+            `import { aventaraConfig } from '${specifier(from, "src/aventara.config", js)}';`,
+            ...(sameFile
+                ? [
+                    `import { ${module.exportName}, ${service.exportName} } from '${specifier(from, service.file.replace(/\.ts$/, ""), js)}';`,
+                ]
+                : [
+                    `import { ${module.exportName} } from '${specifier(from, module.file.replace(/\.ts$/, ""), js)}';`,
+                    `import { ${service.exportName} } from '${specifier(from, service.file.replace(/\.ts$/, ""), js)}';`,
+                ]),
+        ],
+        entries: [
+            `${module.exportName},`,
+            [
+                "AventaraModule.forRootAsync({",
+                `  imports: [${module.exportName}],`,
+                `  inject: [${service.exportName}],`,
+                `  useFactory: async (prisma: ${service.exportName}) => ({`,
+                "    config: await aventaraConfig(prisma),",
+                "  }),",
+                "}),",
+            ].join("\n"),
+        ],
+    };
+}
+function scaffold(input) {
+    const js = input.moduleKind === "esm" ? ".js" : "";
+    const floor = lowestVersionOf(input.entry.range);
+    const provider = PROVIDERS[input.provider];
+    const driver = input.entry.drivers[input.provider];
+    const run = input.packageManager === "pnpm" ? "pnpm exec" : "npx";
+    const artifact = "src/generated/aventara/discovery.artifact.ts";
+    return {
+        files: [
+            { path: SCHEMA, content: schema(input) },
+            { path: "prisma.config.ts", content: prismaConfig() },
+            {
+                path: NEW_SERVICE.file,
+                content: prismaService({ ...input, clientOutput: CLIENT_OUTPUT, js }),
+            },
+            {
+                path: "src/aventara.config.ts",
+                content: aventaraConfig({
+                    ...input,
+                    service: NEW_SERVICE,
+                    artifact,
+                    js,
+                }),
+            },
+        ],
+        env: { DATABASE_URL: provider.databaseUrl },
+        gitignore: ["/src/generated/", ...provider.gitignore],
+        // D1, D9: exactly the version floor the adapter declares; never bare `prisma`.
+        dependencies: { [input.entry.orm.package]: floor, [driver]: floor },
+        devDependencies: { prisma: floor },
+        prepare: prepare({
+            ...input,
+            schema: SCHEMA,
+            clientOutput: CLIENT_OUTPUT,
+            artifact,
+        }),
+        appModule: appModule(NEW_SERVICE, NEW_MODULE, js),
+        nativeBuilds: provider.nativeBuilds,
+        nextSteps: [
+            ...(input.provider === "postgresql"
+                ? ["Set DATABASE_URL in .env to your PostgreSQL database."]
+                : []),
+            `Create the database tables: ${run} prisma db push`,
+        ],
+    };
+}
+function reuse(input) {
+    const js = input.moduleKind === "esm" ? ".js" : "";
+    const { facts } = input;
+    return {
+        files: [
+            ...(input.writeService
+                ? [
+                    {
+                        path: NEW_SERVICE.file,
+                        content: prismaService({
+                            entry: input.entry,
+                            provider: facts.provider,
+                            clientOutput: facts.clientOutput,
+                            js,
+                        }),
+                    },
+                ]
+                : []),
+            {
+                path: "src/aventara.config.ts",
+                content: aventaraConfig({
+                    entry: input.entry,
+                    provider: facts.provider,
+                    service: input.service,
+                    artifact: input.artifact,
+                    js,
+                }),
+            },
+        ],
+        // R6: the developer's Prisma files, `.env` key and versions are theirs.
+        env: {},
+        gitignore: [`/${path.posix.dirname(input.artifact)}/`],
+        dependencies: {},
+        devDependencies: {},
+        prepare: prepare({
+            entry: input.entry,
+            schema: facts.schema,
+            clientOutput: facts.clientOutput,
+            provider: facts.provider,
+            artifact: input.artifact,
+        }),
+        appModule: appModule(input.service, input.module, js),
+        nativeBuilds: [],
+        nextSteps: [],
+    };
+}
+/* ------------------------------------------------------------------ *
+ * Reading an existing Prisma 7 setup (R6)                              *
+ * ------------------------------------------------------------------ */
+function schemaLocation(directory, manifest) {
+    for (const config of CONFIG_FILES) {
+        const file = path.join(directory, config);
+        if (existsSync(file)) {
+            const declared = /\bschema\s*:\s*['"]([^'"]+)['"]/.exec(readFileSync(file, "utf8"))?.[1];
+            if (declared !== undefined) {
+                return path.posix.normalize(declared);
+            }
+        }
+    }
+    const prisma = manifest.prisma;
+    return typeof prisma?.schema === "string"
+        ? path.posix.normalize(prisma.schema)
+        : SCHEMA;
+}
+/** The `.prisma` files of a schema path: the file, or every file in a schema folder. */
+function schemaFiles(directory, schemaPath) {
+    const full = path.join(directory, schemaPath);
+    if (!existsSync(full)) {
+        return [];
+    }
+    if (!statSync(full).isDirectory()) {
+        return [schemaPath];
+    }
+    return readdirSync(full, { recursive: true, withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".prisma"))
+        .map((entry) => path
+        .relative(directory, path.join(entry.parentPath, entry.name))
+        .split(path.sep)
+        .join("/"))
+        .sort();
+}
+function blocks(text, kind) {
+    return [
+        ...text.matchAll(new RegExp(`^\\s*${kind}\\s+\\w+\\s*\\{([^}]*)\\}`, "gm")),
+    ].map((match) => match[1]);
+}
+function setting(block, name) {
+    return new RegExp(`^\\s*${name}\\s*=\\s*"([^"]*)"`, "m").exec(block)?.[1];
+}
+function readProject(directory, manifest) {
+    const schemaPath = schemaLocation(directory, manifest);
+    let provider;
+    let generator;
+    let clientOutput;
+    for (const file of schemaFiles(directory, schemaPath)) {
+        const text = readFileSync(path.join(directory, file), "utf8").replace(/\/\/.*$/gm, "");
+        provider ??= blocks(text, "datasource")
+            .map((block) => setting(block, "provider"))
+            .find((value) => value !== undefined);
+        for (const block of blocks(text, "generator")) {
+            const declared = setting(block, "provider");
+            const output = setting(block, "output");
+            // The client generator, not a second generator (a zod or docs one) beside it.
+            if (generator === undefined || /^prisma-client/.test(declared ?? "")) {
+                generator = declared;
+                clientOutput =
+                    output === undefined
+                        ? undefined
+                        : path.posix.normalize(path.posix.join(path.posix.dirname(file), output));
+            }
+        }
+    }
+    const dependencies = [
+        ...Object.keys(manifest.dependencies ?? {}),
+        ...Object.keys(manifest.devDependencies ?? {}),
+    ];
+    return {
+        schema: schemaPath,
+        provider,
+        generator,
+        clientOutput,
+        drivers: dependencies.filter((name) => name.startsWith(DRIVER_PREFIX)),
+    };
+}
+function clientShape(facts) {
+    return {
+        clientClass: "PrismaClient",
+        importsClient: (imported, file) => {
+            if (!imported.startsWith(".")) {
+                return imported === "@prisma/client";
+            }
+            if (facts.clientOutput === undefined) {
+                return false;
+            }
+            const resolved = path.posix
+                .join(path.posix.dirname(file), imported)
+                .replace(/\.(js|ts)$/, "");
+            return (resolved === facts.clientOutput ||
+                resolved === `${facts.clientOutput}/client` ||
+                resolved === `${facts.clientOutput}/index`);
+        },
+        skip: facts.clientOutput === undefined
+            ? ["src/generated"]
+            : ["src/generated", facts.clientOutput],
+    };
+}
+export const PRISMA7_TEMPLATES = {
+    providers: PROVIDERS,
+    scaffold,
+    readProject,
+    clientShape,
+    newService: { service: NEW_SERVICE, module: NEW_MODULE },
+    reuse,
+};

package/dist/templates/template.registry.d.ts

@@ -0,0 +1,151 @@
+import type { PackageManifest } from "../apply/manifest.merger.js";
+import type { CatalogEntry, EntryId, ProviderOf } from "../catalog/catalog-entry.interface.js";
+import type { ClientShape, ExportReference } from "../project/service.detector.js";
+import type { PackageManager } from "../wizard/wizard.questions.js";
+/**
+ * D7 — what the CLI writes for an ORM lives here as text, keyed by catalog id;
+ * the adapter itself runs only through its bin.
+ *
+ * The registry is **total** in both directions, and both are checked before a
+ * project is ever scaffolded:
+ * - at compile time, over the generated catalog's literal type: an entry with
+ *   no template set, or a template set missing a provider its adapter declares,
+ *   does not type-check;
+ * - at build time, by the catalog generator: a templates directory with no
+ *   adapter, or an adapter with no templates directory, fails the build.
+ */
+/** What changes with the database provider an entry offers. */
+export type ProviderTemplate = {
+    /** The driver adapter's class, constructed in the written ORM service. */
+    readonly driverClass: string;
+    /** The driver class's constructor argument, given the connection string as `url`. */
+    readonly driverOptions: string;
+    /** The `DATABASE_URL` line's value; a placeholder where it cannot be known (Q16-8). */
+    readonly databaseUrl: string;
+    /** `.gitignore` lines this provider's files need (a SQLite database file). */
+    readonly gitignore: readonly string[];
+    /** Packages whose install scripts pnpm must be allowed to run (B9). */
+    readonly nativeBuilds: readonly string[];
+};
+export type ModuleKind = "esm" | "cjs";
+/** What a template set is asked to scaffold. */
+export type ScaffoldInput = {
+    readonly entry: CatalogEntry;
+    /** One of `entry.providers`. */
+    readonly provider: string;
+    readonly moduleKind: ModuleKind;
+    readonly packageManager: PackageManager;
+};
+/**
+ * What an ORM's templates contribute to a project. Everything here is the
+ * ORM's; what is Nest's (the start scripts, the anchored `app.module.ts` edit,
+ * `AventaraModule`'s import) and what is Aventara's (its packages, the
+ * `aventara:prepare` and `postinstall` script names) is the planner's.
+ */
+export type OrmScaffold = {
+    /** New, developer-owned files (§4.3). */
+    readonly files: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+    /** `.env` entries. */
+    readonly env: Readonly<Record<string, string>>;
+    readonly gitignore: readonly string[];
+    readonly dependencies: Readonly<Record<string, string>>;
+    readonly devDependencies: Readonly<Record<string, string>>;
+    /** The command `aventara:prepare` runs (D7: the adapter only through its bin). */
+    readonly prepare: string;
+    /** What the anchored `app.module.ts` edit adds: import lines, and `imports:` entries. */
+    readonly appModule: {
+        readonly imports: readonly string[];
+        readonly entries: readonly string[];
+    };
+    readonly nativeBuilds: readonly string[];
+    /** The ORM's next steps, after the install and before the server starts (R11). */
+    readonly nextSteps: readonly string[];
+};
+/**
+ * What a project's existing ORM setup states, read by the entry's templates
+ * (R6) — the ORM's own file layout is template knowledge (D7); judging it
+ * against the catalog is the matcher's (`catalog.matcher.ts`).
+ */
+export type OrmProjectFacts = {
+    /** The schema the generate step reads, relative to the project root. */
+    readonly schema: string;
+    readonly provider: string | undefined;
+    readonly generator: string | undefined;
+    /** The generated client's directory, relative to the project root. */
+    readonly clientOutput: string | undefined;
+    /** The driver-adapter packages the project depends on. */
+    readonly drivers: readonly string[];
+};
+/** Reusing a project's ORM setup (R6): its schema, its output, its service. */
+export type ReuseInput = {
+    readonly entry: CatalogEntry;
+    readonly facts: OrmProjectFacts & {
+        readonly provider: string;
+        readonly clientOutput: string;
+    };
+    readonly moduleKind: ModuleKind;
+    readonly packageManager: PackageManager;
+    /** The developer's service, or the template's new one when it is to be written. */
+    readonly service: ExportReference & {
+        readonly clientMember?: string;
+    };
+    readonly module: ExportReference;
+    /** Whether `service` and `module` are the template's new file, to be written. */
+    readonly writeService: boolean;
+    /** Where the discovery artifact goes, relative to the project root. */
+    readonly artifact: string;
+};
+export type TemplateSet<I extends EntryId> = {
+    readonly providers: {
+        readonly [P in ProviderOf<I>]: ProviderTemplate;
+    };
+    /** A project with no ORM: everything §4.3 lists. */
+    readonly scaffold: (input: ScaffoldInput) => OrmScaffold;
+    /** Reads an existing setup's facts; `undefined` when there is none to read. */
+    readonly readProject: (directory: string, manifest: PackageManifest) => OrmProjectFacts;
+    /** How the developer's service is recognised in their source. */
+    readonly clientShape: (facts: OrmProjectFacts) => ClientShape;
+    /** The service init writes when the project has none: its file and names. */
+    readonly newService: {
+        readonly service: ExportReference;
+        readonly module: ExportReference;
+    };
+    /** A project with the ORM already set up: no ORM file written or edited (R6). */
+    readonly reuse: (input: ReuseInput) => OrmScaffold;
+};
+export type TemplateRegistry = {
+    readonly [I in EntryId]: TemplateSet<I>;
+};
+export declare const TEMPLATE_REGISTRY: {
+    readonly prisma7: {
+        readonly providers: {
+            readonly sqlite: {
+                readonly driverClass: "PrismaBetterSqlite3";
+                readonly driverOptions: "{ url }";
+                readonly databaseUrl: "file:./dev.db";
+                readonly gitignore: readonly ["/dev.db*"];
+                readonly nativeBuilds: readonly ["@prisma/engines", "better-sqlite3", "prisma"];
+            };
+            readonly postgresql: {
+                readonly driverClass: "PrismaPg";
+                readonly driverOptions: "{ connectionString: url }";
+                readonly databaseUrl: "postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public";
+                readonly gitignore: readonly [];
+                readonly nativeBuilds: readonly ["@prisma/engines", "prisma"];
+            };
+        };
+        readonly scaffold: (input: ScaffoldInput) => OrmScaffold;
+        readonly readProject: (directory: string, manifest: PackageManifest) => OrmProjectFacts;
+        readonly clientShape: (facts: OrmProjectFacts) => ClientShape;
+        readonly newService: {
+            readonly service: ExportReference;
+            readonly module: ExportReference;
+        };
+        readonly reuse: (input: ReuseInput) => OrmScaffold;
+    };
+};
+/** The template set for `entry` — every catalog entry has one (checked at build). */
+export declare function templatesFor(entry: CatalogEntry): TemplateSet<EntryId>;

package/dist/templates/template.registry.js

@@ -0,0 +1,12 @@
+import { PRISMA7_TEMPLATES } from "./prisma7/prisma7.templates.js";
+export const TEMPLATE_REGISTRY = {
+    prisma7: PRISMA7_TEMPLATES,
+};
+/** The template set for `entry` — every catalog entry has one (checked at build). */
+export function templatesFor(entry) {
+    const set = TEMPLATE_REGISTRY[entry.id];
+    if (set === undefined) {
+        throw new Error(`the catalog entry ${entry.id} has no template set; the build should have refused it`);
+    }
+    return set;
+}

package/dist/wizard/answer.resolver.d.ts

@@ -0,0 +1,49 @@
+import type { AnyWizardQuestion, QuestionId, WizardAnswers, WizardContext } from "./wizard.questions.js";
+/**
+ * R5 — how each question gets its answer, in this order:
+ *
+ * 1. **its flag**, validated by the question (a bad value is refused, never
+ *    re-asked);
+ * 2. **the only choice there is** (N3): shown on a terminal with no keypress;
+ * 3. **`--yes`**: the question's default, when it has one;
+ * 4. **the prompt**, when someone can answer (stdin is a terminal);
+ * 5. otherwise the question is **unanswered**, and once every question has been
+ *    tried the run refuses in one sentence naming exactly those flags.
+ *
+ * `--yes` comes before the prompt because it means "accept each unanswered
+ * question's default" (R5 + R2), on a terminal as much as anywhere; a question
+ * with no default (`new`'s `<name>`) is still asked on a terminal.
+ */
+/** The seam to a person (B26): `node:readline/promises` on a terminal, a script in specs. */
+export type Prompter = {
+    /** Whether someone can answer: stdin is a terminal. */
+    readonly interactive: boolean;
+    /** Asks once; resolves with what was typed, `""` for Enter alone. */
+    readonly ask: (request: PromptRequest) => Promise<string>;
+    /** Says one line without asking (N3, and why an answer was not accepted). */
+    readonly say: (line: string) => void;
+};
+export type PromptRequest = {
+    readonly label: string;
+    /** The accepted values, shown with the label; absent for free text. */
+    readonly choices?: readonly string[];
+    readonly defaultValue?: string;
+};
+/** Nobody can answer and some questions are unanswered. A refusal: one sentence. */
+export declare class UnansweredQuestionsError extends Error {
+    readonly name = "UnansweredQuestionsError";
+}
+export type AnswerSources = {
+    /** Raw answers from the command line, by question. */
+    readonly given: Readonly<Partial<Record<QuestionId, string>>>;
+    readonly yes: boolean;
+    readonly prompter: Prompter;
+    readonly context: Omit<WizardContext, "answered">;
+};
+/**
+ * Settles `questions` in order, each later question seeing the earlier answers.
+ *
+ * @throws WizardAnswerError when a flag's value is not an answer.
+ * @throws UnansweredQuestionsError when nobody can answer and something is unanswered.
+ */
+export declare function resolveAnswers(questions: readonly AnyWizardQuestion[], sources: AnswerSources): Promise<Partial<WizardAnswers>>;