@sanity/runtime-cli 17.8.0-next.g5972da4 → 17.9.0-blueprinit.g14aaebd

package/dist/cores/blueprinit/finish.js

@@ -0,0 +1,72 @@
+import { writeConfigFile } from '../../actions/blueprints/config.js';
+import { createEmptyStack } from '../../actions/blueprints/stacks.js';
+import { check } from '../../utils/display/presenters.js';
+import { styleText } from '../../utils/style-text.js';
+import { renderRows } from './columns.js';
+export async function createStackAndFinish(options) {
+    let stack;
+    try {
+        stack = await createEmptyStack({
+            token: options.token,
+            scopeType: 'organization',
+            scopeId: options.organizationId,
+            name: options.stackName,
+            logger: options.log,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: `Local files were written, but Stack creation failed: ${message}`,
+            suggestions: [
+                'Resolve the Stack error, then finish setup with:',
+                `npx ${options.bin} blueprints init --organization-id ${options.organizationId} --stack-name ${options.stackName}`,
+            ],
+        };
+    }
+    try {
+        writeConfigFile(options.blueprintFilePath, {
+            organizationId: options.organizationId,
+            stackId: stack.id,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: `Stack ${stack.id} was created, but the local Blueprint config could not be written: ${message}`,
+            suggestions: [
+                'Finish setup with:',
+                `npx ${options.bin} blueprints init --organization-id ${options.organizationId} --stack-id ${stack.id}`,
+            ],
+        };
+    }
+    options.log('');
+    options.log(check(`Stack ${styleText('bold', stack.name)} created ${styleText('dim', '(org scope, nothing deployed yet)')}`));
+    options.log('');
+    options.log('');
+    options.log(styleText('bold', 'Next steps:'));
+    for (const step of options.nextSteps)
+        options.log(step);
+    return {
+        success: true,
+        json: {
+            organizationId: options.organizationId,
+            projectId: options.projectId,
+            dataset: options.datasetName,
+            stackId: stack.id,
+            stackName: stack.name,
+            files: [...options.files, '.sanity/blueprint.config.json'],
+        },
+    };
+}
+/** A command to run next, and what it does. */
+export function alignSteps(steps) {
+    return renderRows(steps.map(([command, description]) => {
+        const cells = [{ text: command, style: 'cyan', gap: 2 }];
+        if (description)
+            cells.push({ text: description, style: 'dim' });
+        return cells;
+    }));
+}

package/dist/cores/blueprinit/fresh.d.ts

@@ -0,0 +1,3 @@
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+export declare function freshFlow(options: BlueprinitFlowOptions): Promise<CoreResult>;

package/dist/cores/blueprinit/fresh.js

@@ -0,0 +1,219 @@
+import { mkdirSync } from 'node:fs';
+import { corsResourceName, projectBaseName, projectResourceName, STARTER_FUNCTION_NAME, studioSourcePath, } from '../../actions/blueprinit/manifest.js';
+import { getLatestNpmRange } from '../../actions/blueprinit/versions.js';
+import { scaffoldWorkspace } from '../../actions/blueprinit/workspace.js';
+import { createProject } from '../../actions/sanity/create-project.js';
+import { listDatasets } from '../../actions/sanity/datasets.js';
+import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
+import { check } from '../../utils/display/presenters.js';
+import { isInteractive } from '../../utils/interactive.js';
+import { styleText } from '../../utils/style-text.js';
+import { alignSteps, createStackAndFinish } from './finish.js';
+import { chooseNames } from './naming.js';
+import { fileLines, printBlueprintPreview } from './preview.js';
+import { chooseProjectSource } from './project-choice.js';
+import { confirmUnlessSkipped, studioResourceName } from './prompts.js';
+import { coreFailure } from './results.js';
+import { chooseDataset, chooseOrganization, chooseProject } from './selection.js';
+import { promptForTargetDirectory, relativeTargetPath, resolveTargetDirectory } from './target.js';
+/**
+ * Registry versions for the files this flow writes.
+ *
+ * Started before the preview so the lookups overlap the time the reader spends on it.
+ * `getLatestNpmRange` answers `latest` rather than rejecting, so nothing awaits an error.
+ */
+function scaffoldVersions(log) {
+    return Promise.all([
+        getLatestNpmRange('@sanity/blueprints', log),
+        getLatestNpmRange('sanity', log),
+        getLatestNpmRange('@sanity/vision', log),
+    ]);
+}
+export async function freshFlow(options) {
+    const { bin, dir, flags, log, token } = options;
+    const grouped = await groupProjectsByOrganization({ token, logger: log });
+    if (!grouped.ok) {
+        return { success: false, error: `Could not list organizations: ${grouped.error}` };
+    }
+    const organizationResult = await chooseOrganization(grouped.organizations, flags.organizationId, isInteractive);
+    if (!organizationResult.ok)
+        return coreFailure(organizationResult.error);
+    const { organization, projects = [] } = organizationResult.value;
+    const sourceResult = await chooseProjectSource({
+        flags,
+        interactive: isInteractive,
+        projects,
+        organizationName: organization.name,
+    });
+    if (!sourceResult.ok)
+        return coreFailure(sourceResult.error);
+    const source = sourceResult.value;
+    // A project this run creates has no ID yet, and no datasets to list or choose.
+    const selected = source.create
+        ? { displayName: source.displayName, projectId: undefined, datasetName: source.datasetName }
+        : await selectExistingProject({ ...options, projects, organizationName: organization.name });
+    if ('error' in selected)
+        return coreFailure(selected.error);
+    const datasetAction = source.create ? 'create' : 'attach';
+    log(check(`Org: ${organization.name} (${organization.id})`));
+    log(check(source.create
+        ? `New project: ${selected.displayName}, dataset: ${selected.datasetName} (both made for you)`
+        : `Project: ${selected.displayName} (${selected.projectId}), dataset: ${selected.datasetName}`));
+    log('');
+    const baseName = projectBaseName(selected.displayName, selected.projectId ?? organization.id);
+    const projectName = projectResourceName(baseName);
+    const studioName = studioResourceName(flags);
+    const studioSource = studioSourcePath(studioName);
+    const target = options.targetProvided
+        ? { ok: true, value: dir }
+        : resolveTargetDirectory(dir, await promptForTargetDirectory(dir, baseName, isInteractive && !flags.yes), bin);
+    if (!target.ok)
+        return coreFailure(target.error);
+    const targetDir = target.value;
+    const names = await chooseNames({
+        flags,
+        log,
+        token,
+        organizationId: organization.id,
+        baseName,
+        datasetName: selected.datasetName,
+        resourceNames: [
+            projectName,
+            selected.datasetName,
+            corsResourceName(studioName),
+            studioName,
+            STARTER_FUNCTION_NAME,
+        ],
+    });
+    if (!names.ok)
+        return coreFailure(names.error);
+    const { stackName, studioOrigin } = names.value;
+    const versions = scaffoldVersions(log);
+    const { attaches, creates } = printBlueprintPreview({
+        log,
+        organizationName: organization.name,
+        projectId: selected.projectId,
+        projectName: selected.displayName,
+        datasetName: selected.datasetName,
+        datasetAction,
+        createsProject: source.create,
+        studioName,
+        studioOrigin,
+        studioSource,
+        stackName,
+        functionName: STARTER_FUNCTION_NAME,
+    });
+    log(styleText('bold', 'Files to write:'));
+    for (const line of fileLines([
+        ['+', 'sanity.blueprint.ts', 'project + dataset, CORS, studio, function'],
+        ['+', `${studioSource}/`, 'Studio with a "post" type'],
+        ['+', `functions/${STARTER_FUNCTION_NAME}/`, 'sets a post slug from its title'],
+        ['+', '.sanity/blueprint.config.json', `org scope, stack ${stackName}`],
+        ['+', '.gitignore'],
+        ['+', 'package.json'],
+    ])) {
+        log(line);
+    }
+    log('');
+    const confirmed = await confirmUnlessSkipped(flags, isInteractive, `Create this Blueprint workspace for "${selected.displayName}"?`);
+    if (!confirmed)
+        return { success: false, error: 'Initialization cancelled.' };
+    // Created after the confirmation, so a cancelled run leaves no project behind.
+    let projectId = selected.projectId;
+    if (!projectId) {
+        const created = await createProject({
+            token,
+            organizationId: organization.id,
+            displayName: selected.displayName,
+            logger: log,
+        });
+        if (!created.ok || !created.project?.id) {
+            return {
+                success: false,
+                error: `Could not create project "${selected.displayName}": ${created.error}`,
+                suggestions: ['Nothing was written. Run init again, or pass --project-id to use another.'],
+            };
+        }
+        projectId = created.project.id;
+        log('');
+        log(check(`Project ${styleText('bold', selected.displayName)} created (${projectId})`));
+    }
+    const relativeDir = relativeTargetPath(targetDir);
+    const [blueprintsVersion, sanityVersion, visionVersion] = await versions;
+    mkdirSync(targetDir, { recursive: true });
+    const scaffold = scaffoldWorkspace({
+        dir: targetDir,
+        projectId,
+        displayName: selected.displayName,
+        datasetName: selected.datasetName,
+        datasetAction,
+        stackName,
+        projectName,
+        studioName,
+        studioSlug: stackName,
+        studioOrigin,
+        blueprintsVersion,
+        studioVersions: { sanity: sanityVersion, vision: visionVersion },
+    });
+    return await createStackAndFinish({
+        ...options,
+        organizationId: organization.id,
+        projectId,
+        datasetName: selected.datasetName,
+        stackName,
+        blueprintFilePath: scaffold.blueprintFilePath,
+        files: scaffold.files,
+        nextSteps: [
+            ...alignSteps([
+                ...(relativeDir ? [[`cd ${relativeDir}`]] : []),
+                ['npm install'],
+                // The dataset does not exist until deploy, so a created one is deployed before
+                // `sanity dev` opens a Studio that would query it.
+                ...(datasetAction === 'create'
+                    ? [
+                        [
+                            `npx ${bin} blueprints plan`,
+                            `preview the ${attaches} attaches and ${creates} creates`,
+                        ],
+                        [`npx ${bin} blueprints deploy`, `create ${selected.datasetName} and the rest`],
+                        [`npm run dev -w ${studioSource}`, 'open the Studio and add a post'],
+                    ]
+                    : [
+                        [`npm run dev -w ${studioSource}`, 'open the Studio and add a post'],
+                        [
+                            `npx ${bin} blueprints plan`,
+                            `preview the ${attaches} attaches and ${creates} creates`,
+                        ],
+                        [`npx ${bin} blueprints deploy`, 'attach and create them'],
+                    ]),
+                [`npx ${bin} blueprints info`, 'review what the Stack owns'],
+            ]),
+            '',
+            `Your Studio is hosted at ${studioOrigin} after deploy.`,
+            '',
+            `${STARTER_FUNCTION_NAME} fills in a post's slug. Try it on a post you added, then follow the deployed one:`,
+            `  npx ${bin} functions test ${STARTER_FUNCTION_NAME} --document-id <id>` +
+                ` --project-id ${projectId} --dataset ${selected.datasetName} --with-user-token`,
+            `  npx ${bin} functions logs ${STARTER_FUNCTION_NAME}`,
+        ],
+    });
+}
+/** The existing-project path: pick a project, then pick one of its datasets. */
+async function selectExistingProject(options) {
+    const { flags, log, token, organizationName } = options;
+    const projectResult = await chooseProject(options.projects ?? [], flags.projectId, organizationName, isInteractive);
+    if (!projectResult.ok)
+        return { error: projectResult.error };
+    const project = projectResult.value;
+    const datasets = await listDatasets({ token, projectId: project.id, logger: log });
+    if (!datasets.ok)
+        return { error: { message: `Could not list datasets: ${datasets.error}` } };
+    const datasetResult = await chooseDataset(datasets.datasets, flags.datasetName, project.displayName, isInteractive);
+    if (!datasetResult.ok)
+        return { error: datasetResult.error };
+    return {
+        displayName: project.displayName,
+        projectId: project.id,
+        datasetName: datasetResult.value.name,
+    };
+}

package/dist/cores/blueprinit/naming.d.ts

@@ -0,0 +1,27 @@
+import type { Logger } from '../../utils/logger.js';
+import type { Result } from '../../utils/types.js';
+import type { FlowError } from './results.js';
+import type { BlueprinitFlags } from './types.js';
+export interface ChooseNamesOptions {
+    flags: BlueprinitFlags;
+    log: Logger;
+    token: string;
+    organizationId: string;
+    /** The slug form of the project display name, which both defaults are built from. */
+    baseName: string;
+    datasetName: string;
+    /** Every Blueprint-local resource name this flow will write. */
+    resourceNames: string[];
+}
+export interface ChosenNames {
+    stackName: string;
+    studioOrigin: string;
+}
+/**
+ * The two names a flow must settle before it previews anything.
+ *
+ * The Stack name is also the hosted Studio slug, so one answer names both, and the origin
+ * follows from it. Resource names are checked afterwards, because a repeated name writes
+ * a manifest that cannot deploy.
+ */
+export declare function chooseNames(options: ChooseNamesOptions): Promise<Result<ChosenNames, FlowError>>;

package/dist/cores/blueprinit/naming.js

@@ -0,0 +1,43 @@
+import { env } from 'node:process';
+import { defaultStackName, hostedStudioOrigin } from '../../actions/blueprinit/manifest.js';
+import { isInteractive } from '../../utils/interactive.js';
+import { duplicateResourceNames } from './prompts.js';
+import { chooseStackName, takenStackNames } from './stack-name.js';
+/**
+ * The two names a flow must settle before it previews anything.
+ *
+ * The Stack name is also the hosted Studio slug, so one answer names both, and the origin
+ * follows from it. Resource names are checked afterwards, because a repeated name writes
+ * a manifest that cannot deploy.
+ */
+export async function chooseNames(options) {
+    const { flags, log, token, organizationId, baseName, datasetName, resourceNames } = options;
+    const stackNameResult = await chooseStackName({
+        flags,
+        interactive: isInteractive,
+        defaultName: defaultStackName(baseName, datasetName),
+        taken: await takenStackNames({ token, organizationId, log }),
+        log,
+    });
+    if (!stackNameResult.ok) {
+        return {
+            ok: false,
+            error: { message: stackNameResult.error, suggestions: stackNameResult.suggestions },
+        };
+    }
+    const duplicates = duplicateResourceNames(resourceNames);
+    if (duplicates.length > 0) {
+        return {
+            ok: false,
+            error: {
+                message: `Blueprint resource names must be unique. Used twice: ${duplicates.join(', ')}.`,
+                suggestions: ['Pass --studio-name with a different value.'],
+            },
+        };
+    }
+    const stackName = stackNameResult.value;
+    return {
+        ok: true,
+        value: { stackName, studioOrigin: hostedStudioOrigin(stackName, env.SANITY_INTERNAL_ENV) },
+    };
+}

package/dist/cores/blueprinit/preview.d.ts

@@ -0,0 +1,34 @@
+import { type DatasetAction } from '../../actions/blueprinit/manifest.js';
+import type { Logger } from '../../utils/logger.js';
+interface BlueprintPreviewOptions {
+    log: Logger;
+    /** Absent when this run creates the project, because the ID exists only afterwards. */
+    projectId?: string;
+    organizationName: string;
+    projectName: string;
+    datasetName: string;
+    studioName: string;
+    studioOrigin: string;
+    studioSource: string;
+    stackName: string;
+    functionName?: string;
+    datasetAction: DatasetAction;
+    /** Set when this run creates the project before it writes anything. */
+    createsProject?: boolean;
+}
+/** The counts `blueprints plan` will report for this Blueprint. */
+export interface PreviewCounts {
+    attaches: number;
+    creates: number;
+}
+/**
+ * Print the plan, then report the counts it showed.
+ *
+ * The counts come from the rows that were printed, so the table and the totals in the
+ * next steps cannot disagree.
+ */
+export declare function printBlueprintPreview(options: BlueprintPreviewOptions): PreviewCounts;
+/** A local change: a marker, the path, and what the file is for. */
+export type FileLine = [marker: '+' | '~', path: string, description?: string];
+export declare function fileLines(lines: FileLine[]): string[];
+export {};

package/dist/cores/blueprinit/preview.js

@@ -0,0 +1,110 @@
+import { corsResourceName } from '../../actions/blueprinit/manifest.js';
+import { styleText } from '../../utils/style-text.js';
+import { renderRows } from './columns.js';
+/** The icon and colour `blueprints plan` uses for the same action. */
+const ACTION_STYLE = {
+    attach: { icon: '←', color: 'blue' },
+    create: { icon: '+', color: 'green' },
+};
+const RETAIN_SUFFIX = 'retain on Stack removal';
+const RETAIN = `on deploy; ${RETAIN_SUFFIX}`;
+function previewResources(options) {
+    const resources = [
+        {
+            action: 'attach',
+            kind: 'Project',
+            name: options.projectId
+                ? `${options.projectName} (${options.projectId})`
+                : options.projectName,
+            detail: options.projectId ? RETAIN : `once created, ${RETAIN_SUFFIX}`,
+        },
+        {
+            action: options.datasetAction,
+            kind: 'Dataset',
+            name: options.datasetName,
+            detail: options.datasetAction === 'attach' ? RETAIN : `on deploy; ${RETAIN_SUFFIX}`,
+        },
+        {
+            action: 'create',
+            kind: 'CORS Origin',
+            name: corsResourceName(options.studioName),
+            detail: `for ${options.studioOrigin} on deploy`,
+        },
+        {
+            action: 'create',
+            kind: 'Studio',
+            name: options.studioName,
+            // The origin is on the CORS line directly above, so it is not repeated here.
+            detail: `from ${options.studioSource} on deploy`,
+        },
+    ];
+    if (options.functionName) {
+        resources.push({
+            action: 'create',
+            kind: 'Function',
+            name: options.functionName,
+            detail: 'on deploy',
+        });
+    }
+    return resources;
+}
+function actionRow(resource) {
+    const { icon, color } = ACTION_STYLE[resource.action];
+    return [
+        { text: icon, style: ['bold', color] },
+        { text: resource.action, style: color },
+        { text: resource.kind },
+        { text: resource.name, style: 'bold', gap: 2 },
+        { text: resource.detail, style: 'dim' },
+    ];
+}
+/**
+ * Print the plan, then report the counts it showed.
+ *
+ * The counts come from the rows that were printed, so the table and the totals in the
+ * next steps cannot disagree.
+ */
+export function printBlueprintPreview(options) {
+    const resources = previewResources(options);
+    const remote = [];
+    if (options.createsProject) {
+        remote.push({
+            action: 'create',
+            kind: 'Project',
+            name: options.projectName,
+            detail: `in ${options.organizationName}, before any file is written`,
+        });
+    }
+    remote.push({
+        action: 'create',
+        kind: 'Stack',
+        name: options.stackName,
+        detail: `in ${options.organizationName} (empty, organization scope)`,
+    });
+    // One call across both blocks, so one set of widths makes the two read as one table.
+    const rows = renderRows([...resources, ...remote].map(actionRow));
+    const remoteRows = rows.slice(resources.length);
+    options.log(styleText('bold', 'Blueprint plan:'));
+    for (const row of rows.slice(0, resources.length))
+        options.log(row);
+    options.log('');
+    options.log(styleText('bold', remote.length === 1 ? 'One remote change now:' : 'Remote changes now:'));
+    for (const row of remoteRows)
+        options.log(row);
+    options.log('');
+    return {
+        attaches: resources.filter(({ action }) => action === 'attach').length,
+        creates: resources.filter(({ action }) => action === 'create').length,
+    };
+}
+export function fileLines(lines) {
+    return renderRows(lines.map(([marker, path, description]) => {
+        const cells = [
+            { text: marker, style: ['bold', marker === '+' ? 'green' : 'yellow'] },
+            { text: path, style: 'bold', gap: 3 },
+        ];
+        if (description)
+            cells.push({ text: description, style: 'dim' });
+        return cells;
+    }));
+}

package/dist/cores/blueprinit/project-choice.d.ts

@@ -0,0 +1,28 @@
+import type { Project } from '../../actions/sanity/projects.js';
+import type { Result } from '../../utils/types.js';
+import type { FlowError } from './results.js';
+import type { BlueprinitFlags } from './types.js';
+export declare const DEFAULT_DATASET_NAME = "production";
+export declare function datasetNameError(name: string): string | undefined;
+/** What the fresh flow attaches a Blueprint to: a project that exists, or one to create. */
+export type ProjectChoice = {
+    create: false;
+} | {
+    create: true;
+    displayName: string;
+    datasetName: string;
+};
+interface ChooseProjectSourceOptions {
+    flags: BlueprinitFlags;
+    interactive: boolean;
+    projects: Project[];
+    organizationName: string;
+}
+/**
+ * Whether this run creates a project.
+ *
+ * `--create-project` decides it without asking. An organization with no projects has
+ * nothing to select, so creation is the only way forward there.
+ */
+export declare function chooseProjectSource(options: ChooseProjectSourceOptions): Promise<Result<ProjectChoice, FlowError>>;
+export {};

package/dist/cores/blueprinit/project-choice.js

@@ -0,0 +1,82 @@
+import { input, select } from '@inquirer/prompts';
+export const DEFAULT_DATASET_NAME = 'production';
+/**
+ * The dataset name rule the projects API enforces, with `convert: false`.
+ *
+ * Underscores are legal, so a name is checked and refused rather than slugified. The
+ * pattern also rejects a single character, which is why a short name fails here and not
+ * at deploy.
+ */
+const DATASET_NAME_PATTERN = /^[a-z0-9][-_a-z0-9]+$/;
+export function datasetNameError(name) {
+    if (name.length > 64)
+        return 'A dataset name can be at most 64 characters.';
+    if (!DATASET_NAME_PATTERN.test(name)) {
+        return 'A dataset name must be at least 2 characters, and use only a-z, 0-9, - and _, starting with a letter or a digit.';
+    }
+    return undefined;
+}
+/**
+ * Whether this run creates a project.
+ *
+ * `--create-project` decides it without asking. An organization with no projects has
+ * nothing to select, so creation is the only way forward there.
+ */
+export async function chooseProjectSource(options) {
+    const { flags, interactive, projects, organizationName } = options;
+    const named = flags.createProject?.trim();
+    if (!named && (flags.projectId || projects.length > 0)) {
+        if (flags.projectId || !interactive || flags.yes)
+            return { ok: true, value: { create: false } };
+        const source = await select({
+            message: `Use a project in ${organizationName}, or create one?`,
+            choices: [
+                { name: 'Use an existing project', value: 'existing' },
+                { name: 'Create a new project', value: 'new' },
+            ],
+        });
+        if (source === 'existing')
+            return { ok: true, value: { create: false } };
+    }
+    if (!named && !interactive) {
+        return {
+            ok: false,
+            error: {
+                message: `No projects found in ${organizationName}.`,
+                suggestions: ['Pass --create-project <name> to create one.'],
+            },
+        };
+    }
+    const displayName = named || (await promptForProjectName(organizationName));
+    if (!displayName) {
+        return { ok: false, error: { message: 'A new project needs a display name.' } };
+    }
+    const datasetName = await chooseDatasetName(flags, interactive && !flags.yes);
+    if (!datasetName.ok)
+        return datasetName;
+    return { ok: true, value: { create: true, displayName, datasetName: datasetName.value } };
+}
+async function promptForProjectName(organizationName) {
+    const answer = await input({
+        message: `Name your new project in ${organizationName}:`,
+        validate: (value) => value.trim().length > 0 || 'Enter a project name.',
+    });
+    return answer.trim();
+}
+/** The dataset the Blueprint will create, which no API call has made yet. */
+async function chooseDatasetName(flags, interactive) {
+    if (flags.datasetName) {
+        const problem = datasetNameError(flags.datasetName);
+        return problem
+            ? { ok: false, error: { message: `Dataset "${flags.datasetName}" is not valid. ${problem}` } }
+            : { ok: true, value: flags.datasetName };
+    }
+    if (!interactive)
+        return { ok: true, value: DEFAULT_DATASET_NAME };
+    const answer = await input({
+        message: 'Name the dataset this Blueprint will create:',
+        default: DEFAULT_DATASET_NAME,
+        validate: (value) => datasetNameError(value.trim()) ?? true,
+    });
+    return { ok: true, value: answer.trim() };
+}

package/dist/cores/blueprinit/prompts.d.ts

@@ -0,0 +1,13 @@
+import type { BlueprinitFlags } from './types.js';
+/**
+ * Resource names must be unique within a Blueprint, so report every name used twice.
+ *
+ * The generated names cannot collide with each other, because each one carries its
+ * resource type. A dataset name or a `--studio-name` value can still land on one.
+ */
+export declare function duplicateResourceNames(names: string[]): string[];
+export declare function confirmUnlessSkipped(flags: BlueprinitFlags, interactive: boolean, message: string): Promise<boolean>;
+/** The new Stack's name, which is also the hosted Studio slug. */
+export declare function promptForStackName(flags: BlueprinitFlags, interactive: boolean, defaultName: string): Promise<string>;
+/** The Blueprint-local Studio name, which is also its directory under `studios/`. */
+export declare function studioResourceName(flags: BlueprinitFlags): string;