sst 2.0.0-rc.26 → 2.0.0-rc.29

package/bootstrap.d.ts

@@ -1,4 +1,4 @@
 export declare const useBootstrap: () => Promise<{
-    version: undefined;
-    bucket: undefined;
+    version: never;
+    bucket: never;
 }>;

package/bootstrap.js

@@ -23,10 +23,8 @@ const LATEST_VERSION = "4";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 export const useBootstrap = Context.memo(async () => {
     Logger.debug("Initializing bootstrap context");
-    const ret = await loadBootstrapStatus();
-    if (!ret.version ||
-        !ret.bucket ||
-        ret.version !== LATEST_VERSION) {
+    let status = await loadBootstrapStatus();
+    if (!status || status.version !== LATEST_VERSION) {
         const project = useProject();
         const spinner = createSpinner("Deploying bootstrap stack, this only needs to happen once").start();
         // Create bootstrap stack
@@ -89,22 +87,39 @@ export const useBootstrap = Context.memo(async () => {
         // Create stack outputs to store bootstrap stack info
         new CfnOutput(stack, OUTPUT_VERSION, { value: LATEST_VERSION });
         new CfnOutput(stack, OUTPUT_BUCKET, { value: bucket.bucketName });
+        // Deploy bootstrap stack
         const asm = app.synth();
         const result = await Stacks.deploy(asm.stacks[0]);
         if (Stacks.isFailed(result.status)) {
             throw new VisibleError(`Failed to deploy bootstrap stack:\n${JSON.stringify(result.errors, null, 4)}`);
         }
         spinner.succeed();
-        return loadBootstrapStatus();
+        // Fetch bootstrap status
+        status = await loadBootstrapStatus();
+        if (!status) {
+            throw new VisibleError("Failed to deploy bootstrap stack");
+        }
     }
-    Logger.debug("Loaded bootstrap info: ", JSON.stringify(ret));
-    return ret;
+    Logger.debug("Loaded bootstrap info: ", JSON.stringify(status));
+    return status;
 });
 async function loadBootstrapStatus() {
+    // Get bootstrap CloudFormation stack
     const cf = useAWSClient(CloudFormationClient);
-    const result = await cf.send(new DescribeStacksCommand({
-        StackName: STACK_NAME,
-    }));
+    let result;
+    try {
+        result = await cf.send(new DescribeStacksCommand({
+            StackName: STACK_NAME,
+        }));
+    }
+    catch (e) {
+        if (e.Code === "ValidationError"
+            && e.message === `Stack with id ${STACK_NAME} does not exist`) {
+            return null;
+        }
+        throw e;
+    }
+    // Parse stack outputs
     let version, bucket;
     (result.Stacks[0].Outputs || []).forEach((o) => {
         if (o.OutputKey === OUTPUT_VERSION) {
@@ -114,5 +129,8 @@ async function loadBootstrapStatus() {
             bucket = o.OutputValue;
         }
     });
+    if (!version || !bucket) {
+        return null;
+    }
     return { version, bucket };
 }

package/cli/commands/bind.js

@@ -1,12 +1,15 @@
-import { useProject } from "../../project.js";
-export const bind = (program) => program.command("bind <command>", "Binds blah", (yargs) => yargs.positional("command", {
+export const bind = (program) => program.command("bind <command>", "Bind your app's resources to a command", (yargs) => yargs
+    .positional("command", {
     type: "string",
-    describe: "Command to bind to",
+    describe: "The command to bind to",
     demandOption: true,
-}), async (args) => {
+})
+    .example(`sst bind "vitest run"`, "Bind your resources to your tests")
+    .example(`sst bind "tsx scripts/myscript.ts"`, "Bind your resources to a script"), async (args) => {
     const { Config } = await import("../../config.js");
-    const { spawnSync, spawn } = await import("child_process");
+    const { spawnSync } = await import("child_process");
     const { useAWSCredentials } = await import("../../credentials.js");
+    const { useProject } = await import("../../project.js");
     const env = await Config.env();
     const project = useProject();
     const credentials = await useAWSCredentials();

package/cli/commands/build.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="yargs" />
-import { Program } from "../program.js";
+import type { Program } from "../program.js";
 export declare const build: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
@@ -7,5 +7,5 @@ export declare const build: (program: Program) => import("yargs").Argv<{
 } & {
     region: string | undefined;
 } & {
-    from: string | undefined;
+    to: string | undefined;
 }>;

package/cli/commands/build.js

@@ -1,10 +1,14 @@
-import { useProject } from "../../project.js";
-import { createSpinner } from "../spinner.js";
-export const build = (program) => program.command("build", "Build stacks code", (yargs) => yargs.option("from", { type: "string" }), async () => {
+export const build = (program) => program.command("build", "Build your app", (yargs) => yargs.option("to", {
+    type: "string",
+    describe: "Output directory, defaults to .sst/dist",
+}), async (args) => {
+    const { useProject } = await import("../../project.js");
+    const { createSpinner } = await import("../spinner.js");
     const { Stacks } = await import("../../stacks/index.js");
     const spinner = createSpinner("Building stacks").start();
     await Stacks.synth({
         fn: useProject().stacks,
+        buildDir: args.to,
         mode: "deploy",
     });
     spinner.succeed();

package/cli/commands/console.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="yargs" />
-import { Program } from "../program.js";
+import type { Program } from "../program.js";
 export declare const consoleCommand: (program: Program) => Promise<import("yargs").Argv<{
     stage: string | undefined;
 } & {

package/cli/commands/console.js

@@ -1,7 +1,7 @@
-import { blue } from "colorette";
-import { useRuntimeServer } from "../../runtime/server.js";
-import { useLocalServer } from "../local/server.js";
-export const consoleCommand = async (program) => program.command("console", "Start the sst console", (yargs) => yargs, async () => {
+export const consoleCommand = async (program) => program.command("console", "Start the SST Console", (yargs) => yargs, async () => {
+    const { blue } = await import("colorette");
+    const { useRuntimeServer } = await import("../../runtime/server.js");
+    const { useLocalServer } = await import("../local/server.js");
     await Promise.all([
         useRuntimeServer(),
         useLocalServer({

package/cli/commands/deploy.js

@@ -1,14 +1,20 @@
-import { printDeploymentResults } from "../ui/deploy.js";
-import { createSpinner } from "../spinner.js";
-export const deploy = (program) => program.command("deploy [filter]", "Work on your SST app locally", (yargs) => yargs
-    .option("from", { type: "string" })
+export const deploy = (program) => program.command("deploy [filter]", "Deploy your app to AWS", (yargs) => yargs
+    .option("from", {
+    type: "string",
+    describe: "Deploy using previously built output",
+})
     .option("fullscreen", {
     type: "boolean",
     describe: "Disable full screen UI",
     default: true,
 })
-    .positional("filter", { type: "string" }), async (args) => {
+    .positional("filter", {
+    type: "string",
+    describe: "Optionally filter stacks to deploy",
+}), async (args) => {
     const React = await import("react");
+    const { printDeploymentResults } = await import("../ui/deploy.js");
+    const { createSpinner } = await import("../spinner.js");
     const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
     const { blue, bold } = await import("colorette");
     const { useProject } = await import("../../project.js");
@@ -34,18 +40,22 @@ export const deploy = (program) => program.command("deploy [filter]", "Work on y
     if (!target.length) {
         console.log(`No stacks found matching ${blue(args.filter)}`);
         process.exit(1);
-        return;
     }
     console.log(`Deploying ${bold(target.length + " stacks")} for stage ${blue(project.config.stage)}...`);
-    let component = undefined;
-    if (args.fullscreen) {
-        process.stdout.write("\x1b[?1049h");
-        component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
-    }
+    const cleanup = (() => {
+        if (args.fullscreen) {
+            process.stdout.write("\x1b[?1049h");
+            const component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
+            return () => {
+                component.unmount();
+                process.stdout.write("\x1b[?1049l");
+            };
+        }
+        const spinner = createSpinner("Deploying stacks");
+        return () => spinner.succeed();
+    })();
     const results = await Stacks.deployMany(target);
-    if (component)
-        component.unmount();
-    process.stdout.write("\x1b[?1049l");
+    cleanup();
     printDeploymentResults(results);
     if (Object.values(results).some((stack) => Stacks.isFailed(stack.status)))
         process.exit(1);

package/cli/commands/dev.js

@@ -1,16 +1,4 @@
-import path from "path";
-import fs from "fs/promises";
-import crypto from "crypto";
-import { printDeploymentResults } from "../ui/deploy.js";
-import { useFunctions } from "../../constructs/Function.js";
-import { dim, gray, yellow } from "colorette";
-import { SiteEnv } from "../../site-env.js";
-import { usePothosBuilder } from "./plugins/pothos.js";
-import { useKyselyTypeGenerator } from "./plugins/kysely.js";
-import { useRDSWarmer } from "./plugins/warmer.js";
-import { useProject } from "../../project.js";
-import { useMetadata } from "../../stacks/metadata.js";
-export const dev = (program) => program.command(["start", "dev"], "Work on your SST app locally", (yargs) => yargs.option("fullscreen", {
+export const dev = (program) => program.command(["dev", "start"], "Work on your app locally", (yargs) => yargs.option("fullscreen", {
     type: "boolean",
     describe: "Disable full screen UI",
     default: true,
@@ -29,6 +17,18 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
     const { Context } = await import("../../context/context.js");
     const { DeploymentUI } = await import("../ui/deploy.js");
     const { useLocalServer } = await import("../local/server.js");
+    const path = await import("path");
+    const fs = await import("fs/promises");
+    const crypto = await import("crypto");
+    const { printDeploymentResults } = await import("../ui/deploy.js");
+    const { useFunctions } = await import("../../constructs/Function.js");
+    const { dim, gray, yellow } = await import("colorette");
+    const { SiteEnv } = await import("../../site-env.js");
+    const { usePothosBuilder } = await import("./plugins/pothos.js");
+    const { useKyselyTypeGenerator } = await import("./plugins/kysely.js");
+    const { useRDSWarmer } = await import("./plugins/warmer.js");
+    const { useProject } = await import("../../project.js");
+    const { useMetadata } = await import("../../stacks/metadata.js");
     if (args._[0] === "start") {
         console.log(yellow(`Warning: ${bold(`sst start`)} has been renamed to ${bold(`sst dev`)}`));
     }
@@ -108,15 +108,20 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
             const assembly = pending;
             const nextChecksum = await checksum(assembly.directory);
             pending = undefined;
-            let component = undefined;
-            if (args.fullscreen) {
-                process.stdout.write("\x1b[?1049h");
-                component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
-            }
+            const cleanup = (() => {
+                if (args.fullscreen) {
+                    process.stdout.write("\x1b[?1049h");
+                    const component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
+                    return () => {
+                        component.unmount();
+                        process.stdout.write("\x1b[?1049l");
+                    };
+                }
+                const spinner = createSpinner("Deploying stacks");
+                return () => spinner.succeed();
+            })();
             const results = await Stacks.deployMany(assembly.stacks);
-            if (component)
-                component.unmount();
-            process.stdout.write("\x1b[?1049l");
+            cleanup();
             lastDeployed = nextChecksum;
             printDeploymentResults(results);
             const keys = await SiteEnv.keys();

package/cli/commands/diff.d.ts

@@ -7,5 +7,5 @@ export declare const diff: (program: Program) => import("yargs").Argv<{
 } & {
     region: string | undefined;
 } & {
-    mode: string;
+    dev: boolean | undefined;
 }>;

package/cli/commands/diff.js

@@ -1,19 +1,18 @@
-import { useProject } from "../../project.js";
-import { Stacks } from "../../stacks/index.js";
-import { printStackDiff } from "aws-cdk/lib/diff.js";
-import { useAWSClient } from "../../credentials.js";
-import { CloudFormationClient, GetTemplateCommand, } from "@aws-sdk/client-cloudformation";
-import { createSpinner } from "../spinner.js";
-export const diff = (program) => program.command("diff", "", (yargs) => yargs.option("mode", {
-    type: "string",
-    describe: "deploy or dev",
-    default: "deploy",
+export const diff = (program) => program.command("diff", "Compare your app with what is deployed on AWS", (yargs) => yargs.option("dev", {
+    type: "boolean",
+    describe: "Compare in dev mode",
 }), async (args) => {
+    const { printStackDiff } = await import("aws-cdk/lib/diff.js");
+    const { useProject } = await import("../../project.js");
+    const { Stacks } = await import("../../stacks/index.js");
+    const { useAWSClient } = await import("../../credentials.js");
+    const { CloudFormationClient, GetTemplateCommand } = await import("@aws-sdk/client-cloudformation");
+    const { createSpinner } = await import("../spinner.js");
     const spinner = createSpinner("Building stacks");
     const project = useProject();
     const assembly = await Stacks.synth({
         fn: project.stacks,
-        mode: args.mode,
+        mode: args.dev ? "dev" : "deploy",
     });
     spinner.succeed();
     const cfn = useAWSClient(CloudFormationClient);

package/cli/commands/env.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="yargs" />
-import { Program } from "../program.js";
+import type { Program } from "../program.js";
 export declare const env: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {

package/cli/commands/env.js

@@ -1,14 +1,15 @@
-import { useProject } from "../../project.js";
-import { createSpinner } from "../spinner.js";
-import fs from "fs/promises";
-import { SiteEnv } from "../../site-env.js";
-import { spawnSync } from "child_process";
-export const env = (program) => program.command("env <command>", "description", (yargs) => yargs.positional("command", {
+export const env = (program) => program.command("env <command>", "Load environment variables and start your frontend", (yargs) => yargs
+    .positional("command", {
     type: "string",
-    describe: "Command to run with environment variabels loaded",
+    describe: "The command to start your frontend",
     demandOption: true,
-}), async (args) => {
-    const project = useProject();
+})
+    .example(`sst env "next dev"`, "Start Next.js with your environment variables")
+    .example(`sst env "vite dev"`, "Start Vite with your environment variables"), async (args) => {
+    const { createSpinner } = await import("../spinner.js");
+    const fs = await import("fs/promises");
+    const { SiteEnv } = await import("../../site-env.js");
+    const { spawnSync } = await import("child_process");
     let spinner;
     while (true) {
         const exists = await fs

package/cli/commands/remove.d.ts

@@ -8,6 +8,8 @@ export declare const remove: (program: Program) => import("yargs").Argv<{
     region: string | undefined;
 } & {
     from: string | undefined;
+} & {
+    fullscreen: boolean;
 } & {
     filter: string | undefined;
 }>;

package/cli/commands/remove.js

@@ -1,7 +1,14 @@
-import { printDeploymentResults } from "../ui/deploy.js";
-export const remove = (program) => program.command("remove [filter]", "Remove all stacks for this app", (yargs) => yargs
+export const remove = (program) => program.command("remove [filter]", "Remove your app from AWS", (yargs) => yargs
     .option("from", { type: "string" })
-    .positional("filter", { type: "string" }), async (args) => {
+    .option("fullscreen", {
+    type: "boolean",
+    describe: "Disable full screen UI",
+    default: true,
+})
+    .positional("filter", {
+    type: "string",
+    describe: "Optionally filter stacks to remove",
+}), async (args) => {
     const React = await import("react");
     const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
     const { blue, bold } = await import("colorette");
@@ -9,6 +16,8 @@ export const remove = (program) => program.command("remove [filter]", "Remove al
     const { Stacks } = await import("../../stacks/index.js");
     const { render } = await import("ink");
     const { DeploymentUI } = await import("../ui/deploy.js");
+    const { printDeploymentResults } = await import("../ui/deploy.js");
+    const { createSpinner } = await import("../spinner.js");
     const assembly = await (async function () {
         if (args.from) {
             const result = new CloudAssembly(args.from);
@@ -28,11 +37,22 @@ export const remove = (program) => program.command("remove [filter]", "Remove al
         process.exit(1);
     }
     console.log(`Removing ${bold(target.length + " stacks")} for stage ${blue(project.config.stage)}...`);
-    process.stdout.write("\x1b[?1049h");
-    const component = render(React.createElement(DeploymentUI, { stacks: target.map((s) => s.stackName) }));
+    const cleanup = (() => {
+        if (args.fullscreen) {
+            process.stdout.write("\x1b[?1049h");
+            const component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
+            return () => {
+                component.unmount();
+                process.stdout.write("\x1b[?1049l");
+            };
+        }
+        const spinner = createSpinner("Removing stacks");
+        return () => spinner.succeed();
+    })();
     const results = await Stacks.removeMany(target);
-    component.unmount();
-    process.stdout.write("\x1b[?1049l");
+    cleanup();
     printDeploymentResults(results);
+    if (Object.values(results).some((stack) => Stacks.isFailed(stack.status)))
+        process.exit(1);
     process.exit(0);
 });

package/cli/commands/secrets/get.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="yargs" />
 import { Program } from "../../program.js";
-export declare const get: (program: Program) => import("yargs").Argv<import("yargs").Omit<{
+export declare const get: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
     profile: string | undefined;
@@ -8,6 +8,6 @@ export declare const get: (program: Program) => import("yargs").Argv<import("yar
     region: string | undefined;
 } & {
     name: string;
-}, "name"> & {
-    name: string;
+} & {
+    fallback: boolean | undefined;
 }>;

package/cli/commands/secrets/get.js

@@ -1,33 +1,20 @@
-import { red } from "colorette";
-export const get = (program) => program
-    .command("get <name>", "Get secret value", (yargs) => yargs.positional("name", {
+export const get = (program) => program.command("get <name>", "Get the value of a secret", (yargs) => yargs
+    .positional("name", {
     type: "string",
-    describe: "Name of secret",
+    describe: "Name of the secret",
     demandOption: true,
-}), async (args) => {
-    const { Config } = await import("../../../config.js");
-    const { bold } = await import("colorette");
-    try {
-        const result = await Config.getSecret({
-            key: args.name,
-        });
-        console.log(bold(result));
-    }
-    catch {
-        console.log(red(`${bold(args.name)} is not set`));
-    }
 })
-    .command("get-fallback <name>", "Get secret value", (yargs) => yargs.positional("name", {
-    type: "string",
-    describe: "Name of secret",
-    demandOption: true,
+    .option("fallback", {
+    type: "boolean",
+    describe: "Get the fallback value",
 }), async (args) => {
+    const { red } = await import("colorette");
     const { Config } = await import("../../../config.js");
     const { bold } = await import("colorette");
     try {
         const result = await Config.getSecret({
             key: args.name,
-            fallback: true,
+            fallback: args.fallback === true,
         });
         console.log(bold(result));
     }

package/cli/commands/secrets/list.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="yargs" />
-import { Program } from "../../program.js";
+import type { Program } from "../../program.js";
 export declare const list: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
@@ -7,5 +7,5 @@ export declare const list: (program: Program) => import("yargs").Argv<{
 } & {
     region: string | undefined;
 } & {
-    format: string;
+    format: string | undefined;
 }>;

package/cli/commands/secrets/list.js

@@ -1,8 +1,11 @@
-import { Config } from "../../../config.js";
-import { gray } from "colorette";
-export const list = (program) => program.command("list [format]", "Fetch and decrypt all secrets", yargs => yargs.positional("format", { type: "string", default: "table" }), async (args) => {
+export const list = (program) => program.command("list [format]", "Fetch all the secrets", (yargs) => yargs.positional("format", {
+    type: "string",
+    choices: ["table", "env"],
+}), async (args) => {
+    const { Config } = await import("../../../config.js");
+    const { gray } = await import("colorette");
     const secrets = await Config.secrets();
-    switch (args.format) {
+    switch (args.format || "table") {
         case "env":
             for (const [key, value] of Object.entries(secrets)) {
                 console.log(`${key}=${value.value || value.fallback}`);
@@ -10,8 +13,8 @@ export const list = (program) => program.command("list [format]", "Fetch and dec
             break;
         case "table":
             const keys = Object.keys(secrets);
-            const keyLen = Math.max("Secrets".length, ...keys.map(key => key.length));
-            const valueLen = Math.max("Values".length, ...keys.map(key => secrets[key].value
+            const keyLen = Math.max("Secrets".length, ...keys.map((key) => key.length));
+            const valueLen = Math.max("Values".length, ...keys.map((key) => secrets[key].value
                 ? secrets[key].value.length
                 : `${secrets[key].fallback} (fallback)`.length));
             console.log("┌".padEnd(keyLen + 3, "─") +
@@ -23,7 +26,7 @@ export const list = (program) => program.command("list [format]", "Fetch and dec
                 "┼" +
                 "".padEnd(valueLen + 2, "─") +
                 "┤");
-            keys.sort().forEach(key => {
+            keys.sort().forEach((key) => {
                 const value = secrets[key].value
                     ? secrets[key].value
                     : `${secrets[key].fallback} ${gray("(fallback)")}`;

package/cli/commands/secrets/remove.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="yargs" />
-import { Program } from "../../program.js";
-export declare const remove: (program: Program) => import("yargs").Argv<import("yargs").Omit<{
+import type { Program } from "../../program.js";
+export declare const remove: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
     profile: string | undefined;
@@ -8,6 +8,6 @@ export declare const remove: (program: Program) => import("yargs").Argv<import("
     region: string | undefined;
 } & {
     name: string;
-}, "name"> & {
-    name: string;
+} & {
+    fallback: boolean | undefined;
 }>;

package/cli/commands/secrets/remove.js

@@ -1,21 +1,16 @@
-import { Config } from "../../../config.js";
-export const remove = (program) => program
-    .command("remove <name>", "Remove secret", (yargs) => yargs.positional("name", {
-    describe: "Name of secret to remove",
+export const remove = (program) => program.command("remove <name>", "Remove a secret", (yargs) => yargs
+    .positional("name", {
+    describe: "Name of the secret",
     type: "string",
     demandOption: true,
-}), async (args) => {
-    await Config.removeSecret({
-        key: args.name,
-    });
 })
-    .command("remove-fallback <name>", "Remove secret", (yargs) => yargs.positional("name", {
-    describe: "Name of secret to remove",
-    type: "string",
-    demandOption: true,
+    .option("fallback", {
+    type: "boolean",
+    describe: "Remove the fallback value",
 }), async (args) => {
+    const { Config } = await import("../../../config.js");
     await Config.removeSecret({
         key: args.name,
-        fallback: true,
+        fallback: args.fallback === true,
     });
 });

package/cli/commands/secrets/secrets.js

@@ -1,14 +1,11 @@
-import { get } from "./get.js";
-import { list } from "./list.js";
-import { remove } from "./remove.js";
 import { set } from "./set.js";
 export function secrets(program) {
-    program.command("secrets", "Manage secrets", (yargs) => {
+    program.command("secrets", "Manage the secrets in your app", (yargs) => {
         yargs.demandCommand(1);
-        remove(yargs);
-        get(yargs);
-        list(yargs);
         set(yargs);
+        // get(yargs);
+        // list(yargs);
+        // remove(yargs);
         return yargs;
     });
 }

package/cli/commands/secrets/set.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="yargs" />
-import { Program } from "../../program.js";
-export declare const set: (program: Program) => import("yargs").Argv<import("yargs").Omit<import("yargs").Omit<{
+import type { Program } from "../../program.js";
+export declare const set: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
     profile: string | undefined;
@@ -10,8 +10,6 @@ export declare const set: (program: Program) => import("yargs").Argv<import("yar
     name: string;
 } & {
     value: string;
-}, "name"> & {
-    name: string;
-}, "value"> & {
-    value: string;
+} & {
+    fallback: boolean | undefined;
 }>;