create-better-t-stack/dist/index.d.mts

A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations

#!/usr/bin/env node
import * as _orpc_server0 from "@orpc/server";
import * as better_result0 from "better-result";
import { Result, Result as Result$1 } from "better-result";
import * as trpc_cli0 from "trpc-cli";
import z from "zod";
import { EMBEDDED_TEMPLATES, GeneratorError, GeneratorError as GeneratorError$1, GeneratorOptions, TEMPLATE_COUNT, VirtualDirectory, VirtualFile, VirtualFileSystem, VirtualFileTree, VirtualFileTree as VirtualFileTree$1, VirtualNode, generate } from "@better-t-stack/template-generator";

//#region src/types.d.ts

import * as import__better_t_stack_types from "@better-t-stack/types";
//#endregion
//#region src/helpers/core/command-handlers.d.ts
/**
 * Result type for project creation
 */
interface CreateProjectResult {
  success: boolean;
  projectConfig: types_d_exports.ProjectConfig;
  reproducibleCommand: string;
  timeScaffolded: string;
  elapsedTimeMs: number;
  projectDirectory: string;
  relativePath: string;
  error?: string;
}
//#endregion
//#region src/helpers/core/add-handler.d.ts
interface AddResult {
  success: boolean;
  addedAddons: types_d_exports.Addons[];
  projectDir: string;
  error?: string;
}
//#endregion
//#region src/utils/errors.d.ts
declare const UserCancelledError_base: better_result0.TaggedErrorClass<"UserCancelledError", {
  message: string;
}>;
/**
 * User cancelled the operation (e.g., Ctrl+C in prompts)
 */
declare class UserCancelledError extends UserCancelledError_base {
  constructor(args?: {
    message?: string;
  });
}
declare const CLIError_base: better_result0.TaggedErrorClass<"CLIError", {
  message: string;
  cause?: unknown;
}>;
/**
 * General CLI error for validation failures, invalid flags, etc.
 */
declare class CLIError extends CLIError_base {}
declare const ValidationError_base: better_result0.TaggedErrorClass<"ValidationError", {
  field?: string;
  value?: unknown;
  message: string;
}>;
/**
 * Validation error for config/flag validation failures
 */
declare class ValidationError extends ValidationError_base {
  constructor(args: {
    field?: string;
    value?: unknown;
    message: string;
  });
}
declare const CompatibilityError_base: better_result0.TaggedErrorClass<"CompatibilityError", {
  options: string[];
  message: string;
}>;
/**
 * Compatibility error for incompatible option combinations
 */
declare class CompatibilityError extends CompatibilityError_base {
  constructor(args: {
    options: string[];
    message: string;
  });
}
declare const DirectoryConflictError_base: better_result0.TaggedErrorClass<"DirectoryConflictError", {
  directory: string;
  message: string;
}>;
/**
 * Directory conflict error when target directory exists and is not empty
 */
declare class DirectoryConflictError extends DirectoryConflictError_base {
  constructor(args: {
    directory: string;
  });
}
declare const ProjectCreationError_base: better_result0.TaggedErrorClass<"ProjectCreationError", {
  phase: string;
  message: string;
  cause?: unknown;
}>;
/**
 * Project creation error for failures during scaffolding
 */
declare class ProjectCreationError extends ProjectCreationError_base {
  constructor(args: {
    phase: string;
    message: string;
    cause?: unknown;
  });
}
declare const DatabaseSetupError_base: better_result0.TaggedErrorClass<"DatabaseSetupError", {
  provider: string;
  message: string;
  cause?: unknown;
}>;
/**
 * Database setup error for failures during database configuration
 */
declare class DatabaseSetupError extends DatabaseSetupError_base {
  constructor(args: {
    provider: string;
    message: string;
    cause?: unknown;
  });
}
//#endregion
//#region src/index.d.ts
declare const router: {
  create: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, z.ZodTuple<[z.ZodOptional<z.ZodString>, z.ZodObject<{
    template: z.ZodOptional<z.ZodEnum<{
      none: "none";
      mern: "mern";
      pern: "pern";
      t3: "t3";
      uniwind: "uniwind";
    }>>;
    yes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    yolo: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    verbose: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    database: z.ZodOptional<z.ZodEnum<{
      none: "none";
      sqlite: "sqlite";
      postgres: "postgres";
      mysql: "mysql";
      mongodb: "mongodb";
    }>>;
    orm: z.ZodOptional<z.ZodEnum<{
      none: "none";
      drizzle: "drizzle";
      prisma: "prisma";
      mongoose: "mongoose";
    }>>;
    auth: z.ZodOptional<z.ZodEnum<{
      none: "none";
      "better-auth": "better-auth";
      clerk: "clerk";
    }>>;
    payments: z.ZodOptional<z.ZodEnum<{
      none: "none";
      polar: "polar";
    }>>;
    frontend: z.ZodOptional<z.ZodArray<z.ZodEnum<{
      none: "none";
      "tanstack-router": "tanstack-router";
      "react-router": "react-router";
      "tanstack-start": "tanstack-start";
      next: "next";
      nuxt: "nuxt";
      "native-bare": "native-bare";
      "native-uniwind": "native-uniwind";
      "native-unistyles": "native-unistyles";
      svelte: "svelte";
      solid: "solid";
      astro: "astro";
    }>>>;
    addons: z.ZodOptional<z.ZodArray<z.ZodEnum<{
      none: "none";
      pwa: "pwa";
      tauri: "tauri";
      starlight: "starlight";
      biome: "biome";
      lefthook: "lefthook";
      husky: "husky";
      ruler: "ruler";
      mcp: "mcp";
      turborepo: "turborepo";
      fumadocs: "fumadocs";
      ultracite: "ultracite";
      oxlint: "oxlint";
      opentui: "opentui";
      wxt: "wxt";
      skills: "skills";
    }>>>;
    examples: z.ZodOptional<z.ZodArray<z.ZodEnum<{
      none: "none";
      todo: "todo";
      ai: "ai";
    }>>>;
    git: z.ZodOptional<z.ZodBoolean>;
    packageManager: z.ZodOptional<z.ZodEnum<{
      bun: "bun";
      npm: "npm";
      pnpm: "pnpm";
    }>>;
    install: z.ZodOptional<z.ZodBoolean>;
    dbSetup: z.ZodOptional<z.ZodEnum<{
      none: "none";
      turso: "turso";
      neon: "neon";
      "prisma-postgres": "prisma-postgres";
      planetscale: "planetscale";
      "mongodb-atlas": "mongodb-atlas";
      supabase: "supabase";
      d1: "d1";
      docker: "docker";
    }>>;
    backend: z.ZodOptional<z.ZodEnum<{
      none: "none";
      hono: "hono";
      express: "express";
      fastify: "fastify";
      elysia: "elysia";
      convex: "convex";
      self: "self";
    }>>;
    runtime: z.ZodOptional<z.ZodEnum<{
      none: "none";
      bun: "bun";
      node: "node";
      workers: "workers";
    }>>;
    api: z.ZodOptional<z.ZodEnum<{
      none: "none";
      trpc: "trpc";
      orpc: "orpc";
    }>>;
    webDeploy: z.ZodOptional<z.ZodEnum<{
      none: "none";
      cloudflare: "cloudflare";
    }>>;
    serverDeploy: z.ZodOptional<z.ZodEnum<{
      none: "none";
      cloudflare: "cloudflare";
    }>>;
    directoryConflict: z.ZodOptional<z.ZodEnum<{
      merge: "merge";
      overwrite: "overwrite";
      increment: "increment";
      error: "error";
    }>>;
    renderTitle: z.ZodOptional<z.ZodBoolean>;
    disableAnalytics: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    manualDb: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
  }, z.core.$strip>], null>, _orpc_server0.Schema<CreateProjectResult | undefined, CreateProjectResult | undefined>, _orpc_server0.MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
  sponsors: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, _orpc_server0.Schema<unknown, unknown>, _orpc_server0.Schema<void, void>, _orpc_server0.MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
  docs: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, _orpc_server0.Schema<unknown, unknown>, _orpc_server0.Schema<void, void>, _orpc_server0.MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
  builder: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, _orpc_server0.Schema<unknown, unknown>, _orpc_server0.Schema<void, void>, _orpc_server0.MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
  add: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, z.ZodObject<{
    addons: z.ZodOptional<z.ZodArray<z.ZodEnum<{
      none: "none";
      pwa: "pwa";
      tauri: "tauri";
      starlight: "starlight";
      biome: "biome";
      lefthook: "lefthook";
      husky: "husky";
      ruler: "ruler";
      mcp: "mcp";
      turborepo: "turborepo";
      fumadocs: "fumadocs";
      ultracite: "ultracite";
      oxlint: "oxlint";
      opentui: "opentui";
      wxt: "wxt";
      skills: "skills";
    }>>>;
    install: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    packageManager: z.ZodOptional<z.ZodEnum<{
      bun: "bun";
      npm: "npm";
      pnpm: "pnpm";
    }>>;
    projectDir: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>, _orpc_server0.Schema<void, void>, _orpc_server0.MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
  history: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    clear: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
  }, z.core.$strip>, _orpc_server0.Schema<void, void>, _orpc_server0.MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
};
declare function createBtsCli(): trpc_cli0.TrpcCli;
/**
 * Error types that can be returned from create/createVirtual
 */
type CreateError = UserCancelledError | CLIError | ProjectCreationError;
/**
 * Programmatic API to create a new Better-T-Stack project.
 * Returns a Result type - no console output, no interactive prompts.
 *
 * @example
 * ```typescript
 * import { create, Result } from "create-better-t-stack";
 *
 * const result = await create("my-app", {
 *   frontend: ["tanstack-router"],
 *   backend: "hono",
 *   runtime: "bun",
 *   database: "sqlite",
 *   orm: "drizzle",
 * });
 *
 * result.match({
 *   ok: (data) => console.log(`Project created at: ${data.projectDirectory}`),
 *   err: (error) => console.error(`Failed: ${error.message}`),
 * });
 *
 * // Or use unwrapOr for a default value
 * const data = result.unwrapOr(null);
 * ```
 */
declare function create(projectName?: string, options?: Partial<types_d_exports.CreateInput>): Promise<Result$1<types_d_exports.InitResult, CreateError>>;
declare function sponsors(): Promise<void>;
declare function docs(): Promise<void>;
declare function builder(): Promise<void>;
/**
 * Programmatic API to generate a project in-memory (virtual filesystem).
 * Returns a Result with a VirtualFileTree without writing to disk.
 * Useful for web previews and testing.
 *
 * @example
 * ```typescript
 * import { createVirtual, EMBEDDED_TEMPLATES, Result } from "create-better-t-stack";
 *
 * const result = await createVirtual({
 *   frontend: ["tanstack-router"],
 *   backend: "hono",
 *   runtime: "bun",
 *   database: "sqlite",
 *   orm: "drizzle",
 * });
 *
 * result.match({
 *   ok: (tree) => console.log(`Generated ${tree.fileCount} files`),
 *   err: (error) => console.error(`Failed: ${error.message}`),
 * });
 * ```
 */
declare function createVirtual(options: Partial<Omit<types_d_exports.ProjectConfig, "projectDir" | "relativePath">>): Promise<Result$1<VirtualFileTree$1, GeneratorError$1>>;
/**
 * Programmatic API to add addons to an existing Better-T-Stack project.
 *
 * @example
 * ```typescript
 * import { add } from "create-better-t-stack";
 *
 * const result = await add({
 *   addons: ["biome", "husky"],
 *   install: true,
 * });
 *
 * if (result?.success) {
 *   console.log(`Added: ${result.addedAddons.join(", ")}`);
 * }
 * ```
 */
declare function add(options?: {
  addons?: types_d_exports.Addons[];
  install?: boolean;
  packageManager?: types_d_exports.PackageManager;
  projectDir?: string;
}): Promise<AddResult | undefined>;
type API = import__better_t_stack_types.API;
type Addons = import__better_t_stack_types.Addons;
type Auth = import__better_t_stack_types.Auth;
type Backend = import__better_t_stack_types.Backend;
type BetterTStackConfig = import__better_t_stack_types.BetterTStackConfig;
type CreateInput = import__better_t_stack_types.CreateInput;
type Database = import__better_t_stack_types.Database;
type DatabaseSetup = import__better_t_stack_types.DatabaseSetup;
type DirectoryConflict = import__better_t_stack_types.DirectoryConflict;
type Examples = import__better_t_stack_types.Examples;
type Frontend = import__better_t_stack_types.Frontend;
type InitResult = import__better_t_stack_types.InitResult;
type ORM = import__better_t_stack_types.ORM;
type PackageManager = import__better_t_stack_types.PackageManager;
type Payments = import__better_t_stack_types.Payments;
type Runtime = import__better_t_stack_types.Runtime;
type ServerDeploy = import__better_t_stack_types.ServerDeploy;
type Template = import__better_t_stack_types.Template;
type WebDeploy = import__better_t_stack_types.WebDeploy;
export { type API, type AddResult, type Addons, type Auth, type Backend, type BetterTStackConfig, CLIError, CompatibilityError, CreateError, type CreateInput, type Database, type DatabaseSetup, DatabaseSetupError, type DirectoryConflict, DirectoryConflictError, EMBEDDED_TEMPLATES, type Examples, type Frontend, GeneratorError, type GeneratorOptions, type InitResult, type ORM, type PackageManager, type Payments, ProjectCreationError, Result, type Runtime, type ServerDeploy, TEMPLATE_COUNT, type Template, UserCancelledError, ValidationError, type VirtualDirectory, type VirtualFile, VirtualFileSystem, type VirtualFileTree, type VirtualNode, type WebDeploy, add, builder, create, createBtsCli, createVirtual, docs, generate, router, sponsors };