@reliverse/dler 1.7.15 → 1.7.17

package/bin/app/unpack/cmd.js

@@ -0,0 +1,200 @@
+import path from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { createJiti } from "jiti";
+import { promises as fs } from "node:fs";
+import { TPLS_DIR, BINARIES_DIR } from "../../libs/sdk/sdk-impl/utils/pack-unpack/pu-constants.js";
+const jiti = createJiti(import.meta.url);
+async function removeEmptyDirs(dirPath) {
+  if (!await fs.access(dirPath).then(() => true).catch(() => false))
+    return;
+  const entries = await fs.readdir(dirPath);
+  if (entries.length === 0) {
+    await fs.rmdir(dirPath);
+    const parentDir = path.dirname(dirPath);
+    if (parentDir !== dirPath) {
+      await removeEmptyDirs(parentDir);
+    }
+  }
+}
+async function deleteTemplates(templatesDir, templatesDirName, dryRun) {
+  const modFile = `${templatesDirName}-mod.ts`;
+  const typesFile = `${templatesDirName}-types.ts`;
+  const implDir = path.join(templatesDir, TPLS_DIR);
+  const binariesDir = path.join(implDir, BINARIES_DIR);
+  const filesToRemove = [path.join(templatesDir, modFile), path.join(templatesDir, typesFile)];
+  try {
+    const templateFiles = await fs.readdir(implDir);
+    for (const file of templateFiles) {
+      if (file.endsWith(".ts")) {
+        filesToRemove.push(path.join(implDir, file));
+      }
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  for (const file of filesToRemove) {
+    if (dryRun) {
+      relinka("log", `[DRY RUN] Would remove: ${file}`);
+      continue;
+    }
+    try {
+      await fs.unlink(file);
+      relinka("log", `Removed: ${file}`);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        relinka("warn", `Failed to remove ${file}: ${error.message}`);
+      }
+    }
+  }
+  try {
+    if (await fs.access(binariesDir).then(() => true).catch(() => false)) {
+      if (dryRun) {
+        relinka("log", `[DRY RUN] Would remove directory: ${binariesDir}`);
+      } else {
+        await fs.rm(binariesDir, { recursive: true });
+        relinka("log", `Removed directory: ${binariesDir}`);
+      }
+    }
+  } catch (error) {
+    relinka("warn", `Failed to remove binaries directory: ${error.message}`);
+  }
+  await removeEmptyDirs(implDir);
+  await removeEmptyDirs(templatesDir);
+}
+export default defineCommand({
+  meta: {
+    name: "unpack",
+    version: "1.1.0",
+    description: "Creates file structure from packed templates"
+  },
+  args: defineArgs({
+    templatesDir: { type: "positional", required: true, description: "Dir containing *-mod.ts" },
+    output: { type: "string", default: "unpacked", description: "Where to write files" },
+    cdn: {
+      type: "string",
+      description: "Remote CDN base for binary assets download (not yet implemented)"
+    },
+    deleteTemplates: {
+      type: "boolean",
+      description: "Delete template implementation files (*-mod.ts, *-types.ts, etc.)",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without applying them",
+      default: false
+    },
+    force: {
+      type: "boolean",
+      description: "Force overwrite existing files",
+      default: false
+    },
+    cleanup: {
+      type: "boolean",
+      description: "Delete output directory before unpacking",
+      default: false
+    }
+  }),
+  async run({ args }) {
+    if (args.cdn) throw new Error("Remote CDN support is not implemented yet.");
+    const templatesDir = path.resolve(args.templatesDir);
+    const templatesDirName = path.basename(templatesDir);
+    const modFile = `${templatesDirName}-mod.ts`;
+    const modPath = path.join(templatesDir, modFile);
+    if (args.deleteTemplates) {
+      await deleteTemplates(templatesDir, templatesDirName, args["dry-run"]);
+      if (args["dry-run"]) {
+        relinka("log", "[DRY RUN] Templates deletion completed");
+      } else {
+        relinka("log", "Templates deletion completed");
+      }
+      return;
+    }
+    if (args.cleanup) {
+      try {
+        await fs.rm(args.output, { recursive: true, force: true });
+        await fs.mkdir(args.output, { recursive: true });
+        relinka("log", `Cleaned output directory: ${args.output}`);
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
+    }
+    const mod = await jiti.import(modPath);
+    const templatesObj = mod?.DLER_TEMPLATES || mod?.default || (() => {
+      throw new Error(`Invalid ${modFile}`);
+    })();
+    for (const tpl of Object.values(templatesObj)) {
+      await restoreTemplate(tpl, templatesDir, args.output, args.force);
+    }
+    const relativeOutput = path.relative(process.cwd(), args.output);
+    relinka(
+      "log",
+      `Unpacked ${Object.keys(templatesObj).length} templates from ${modFile} into ${relativeOutput}${args.force ? " (--force is true, dir was overwritten)" : ""}`
+    );
+  }
+});
+const restoreTemplate = async (tpl, templatesRoot, outRoot, force) => {
+  const existingFiles = [];
+  for (const [rel, meta] of Object.entries(tpl.config.files)) {
+    const destAbs = path.join(outRoot, rel);
+    if (!force) {
+      try {
+        await fs.access(destAbs);
+        existingFiles.push(rel);
+        continue;
+      } catch {
+      }
+    }
+    await fs.mkdir(path.dirname(destAbs), { recursive: true });
+    switch (meta.type) {
+      case "binary": {
+        if (!meta.binaryHash) {
+          await fs.writeFile(destAbs, "");
+          break;
+        }
+        const ext = path.extname(rel);
+        const binPath = path.join(
+          templatesRoot,
+          TPLS_DIR,
+          BINARIES_DIR,
+          `${meta.binaryHash}${ext}`
+        );
+        await fs.copyFile(binPath, destAbs);
+        break;
+      }
+      case "text": {
+        await fs.writeFile(destAbs, meta.content, "utf8");
+        break;
+      }
+      case "json": {
+        const txt = JSON.stringify(meta.content, null, 2);
+        const withComments = meta.jsonComments ? injectComments(txt, meta.jsonComments) : txt;
+        await fs.writeFile(destAbs, withComments, "utf8");
+        break;
+      }
+    }
+  }
+  if (existingFiles.length > 0) {
+    throw new Error(
+      `Cannot unpack: ${existingFiles.length} file(s) already exist. Use --force to overwrite existing files`
+    );
+  }
+};
+const injectComments = (json, comments) => {
+  const lines = json.split("\n");
+  const entries = Object.entries(comments).map(([k, v]) => [Number(k), v]).sort((a, b) => a[0] - b[0]);
+  let offset = 0;
+  for (const [ln, comment] of entries) {
+    const idx = ln - 1 + offset;
+    const indent = lines[idx]?.match(/^\s*/)?.[0] ?? "";
+    const block = comment.split("\n").map((l) => indent + l);
+    lines.splice(idx, 0, ...block);
+    offset += block.length;
+  }
+  return lines.join("\n") + "\n";
+};

package/bin/cli.js

@@ -10,8 +10,8 @@ import {
 } from "@reliverse/rempts";
 import { promptAggCommand } from "./app/agg/run.js";
 import { getBuildCmd, getPubCmd, getInitCmd, getRenameCmd } from "./app/cmds.js";
-import { showEndPrompt, showStartPrompt } from "./libs/sdk/sdk-impl/cfg/info.js";
-import { ensureDlerConfig } from "./libs/sdk/sdk-impl/cfg/init.js";
+import { showEndPrompt, showStartPrompt } from "./libs/sdk/sdk-impl/config/info.js";
+import { ensureDlerConfig } from "./libs/sdk/sdk-impl/config/init.js";
 const INTERACTIVE_CMDS = ["agg", "build", "pub"];
 async function runCmd(cmdPromise, args) {
   const cmd = await cmdPromise;

package/bin/libs/cfg/cfg-mod.d.ts

@@ -0,0 +1,69 @@
+import type { DlerConfig } from "./types";
+/**
+ * Default configuration for the build and publish logic.
+ */
+export declare const DEFAULT_CONFIG_DLER: DlerConfig;
+export declare const defineConfigDler: (userConfig?: Partial<DlerConfig>) => {
+    bumpDisable: boolean;
+    bumpFilter: string[];
+    bumpMode: import("./types").BumpMode;
+    bumpSet: string;
+    commonPubPause: boolean;
+    commonPubRegistry: "jsr" | "npm" | "npm-jsr";
+    commonVerbose: boolean;
+    coreDeclarations: boolean;
+    coreEntryFile: string;
+    coreEntrySrcDir: string;
+    coreBuildOutDir: string;
+    coreIsCLI: {
+        enabled: boolean;
+        scripts: Record<string, string>;
+    };
+    coreDescription: string;
+    distJsrAllowDirty: boolean;
+    distJsrBuilder: import("./types").BundlerName;
+    distJsrDirName: string;
+    distJsrDryRun: boolean;
+    distJsrFailOnWarn: boolean;
+    distJsrGenTsconfig: boolean;
+    distJsrOutFilesExt: import("./types").NpmOutExt;
+    distJsrSlowTypes: boolean;
+    distNpmBuilder: import("./types").BundlerName;
+    distNpmDirName: string;
+    distNpmOutFilesExt: import("./types").NpmOutExt;
+    libsActMode: "libs-only" | "main-and-libs" | "main-project-only";
+    libsDirDist: string;
+    libsDirSrc: string;
+    libsList: Record<string, import("./types").LibConfig>;
+    logsFileName: string;
+    logsFreshFile: boolean;
+    filterDepsPatterns: {
+        global: string[];
+        "dist-npm": string[];
+        "dist-jsr": string[];
+        "dist-libs": Record<string, {
+            npm: string[];
+            jsr: string[];
+        }>;
+    };
+    transpileFailOnWarn: boolean;
+    transpileEsbuild: import("./types").Esbuild;
+    transpileFormat: import("./types").transpileFormat;
+    transpileMinify: boolean;
+    transpilePublicPath: string;
+    transpileSourcemap: import("./types").Sourcemap;
+    transpileSplitting: boolean;
+    transpileStub: boolean;
+    transpileTarget: import("./types").transpileTarget;
+    transpileWatch: boolean;
+    publishArtifacts?: {
+        global: string[];
+        "dist-jsr": string[];
+        "dist-npm": string[];
+        "dist-libs": Record<string, {
+            jsr: string[];
+            npm: string[];
+        }>;
+    };
+};
+export * from "./rse/rse-mod";

package/bin/libs/cfg/cfg-mod.js

@@ -0,0 +1,61 @@
+export const DEFAULT_CONFIG_DLER = {
+  bumpDisable: false,
+  bumpFilter: ["package.json", ".config/rse.ts"],
+  bumpMode: "patch",
+  bumpSet: "",
+  commonPubPause: true,
+  commonPubRegistry: "npm",
+  commonVerbose: false,
+  coreDeclarations: true,
+  coreDescription: "",
+  coreEntryFile: "mod.ts",
+  coreEntrySrcDir: "src",
+  coreBuildOutDir: "bin",
+  coreIsCLI: { enabled: false, scripts: {} },
+  distJsrAllowDirty: true,
+  distJsrBuilder: "jsr",
+  distJsrDirName: "dist-jsr",
+  distJsrDryRun: false,
+  distJsrFailOnWarn: false,
+  distJsrGenTsconfig: false,
+  distJsrOutFilesExt: "ts",
+  distJsrSlowTypes: true,
+  distNpmBuilder: "mkdist",
+  distNpmDirName: "dist-npm",
+  distNpmOutFilesExt: "js",
+  libsActMode: "main-project-only",
+  libsDirDist: "dist-libs",
+  libsDirSrc: "src/libs",
+  libsList: {},
+  logsFileName: ".logs/relinka.log",
+  logsFreshFile: true,
+  // Dependency filtering
+  filterDepsPatterns: {
+    global: ["@types", "biome", "eslint", "knip", "prettier", "typescript", "@reliverse/dler"],
+    "dist-npm": [],
+    "dist-jsr": [],
+    "dist-libs": {}
+  },
+  // Build setup
+  transpileFailOnWarn: false,
+  transpileEsbuild: "es2023",
+  transpileFormat: "esm",
+  transpileMinify: true,
+  transpilePublicPath: "/",
+  transpileSourcemap: "none",
+  transpileSplitting: false,
+  transpileStub: false,
+  transpileTarget: "node",
+  transpileWatch: false,
+  // Publish artifacts configuration
+  publishArtifacts: {
+    global: ["package.json", "README.md", "LICENSE"],
+    "dist-jsr": [],
+    "dist-npm": [],
+    "dist-libs": {}
+  }
+};
+export const defineConfigDler = (userConfig = {}) => {
+  return { ...DEFAULT_CONFIG_DLER, ...userConfig };
+};
+export * from "./rse/rse-mod.js";

package/bin/libs/cfg/rse/rse-impl/rse-biome.d.ts

@@ -0,0 +1,2 @@
+import type { BiomeConfigResult } from "./rse-types";
+export declare function getBiomeConfig(projectPath: string): Promise<BiomeConfigResult>;

package/bin/libs/cfg/rse/rse-impl/rse-biome.js

@@ -0,0 +1,34 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { parseJSONC } from "confbox";
+let cachedBiomeConfig = null;
+export async function getBiomeConfig(projectPath) {
+  if (cachedBiomeConfig !== null) {
+    return cachedBiomeConfig;
+  }
+  try {
+    const biomePath = path.join(projectPath, "biome.jsonc");
+    if (await fs.pathExists(biomePath)) {
+      const content = await fs.readFile(biomePath, "utf-8");
+      const config = parseJSONC(content);
+      cachedBiomeConfig = {
+        lineWidth: config.formatter?.lineWidth ?? 80,
+        indentStyle: config.formatter?.indentStyle ?? "space",
+        indentWidth: config.formatter?.indentWidth ?? 2,
+        quoteMark: config.javascript?.formatter?.quoteStyle ?? "double",
+        semicolons: config.javascript?.formatter?.semicolons === "always",
+        trailingComma: config.javascript?.formatter?.trailingComma === "all"
+      };
+      return cachedBiomeConfig;
+    }
+  } catch (error) {
+    relinka(
+      "verbose",
+      "Error reading biome config:",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  cachedBiomeConfig = null;
+  return null;
+}

package/bin/libs/cfg/rse/rse-impl/rse-consts.d.ts

@@ -0,0 +1,35 @@
+export declare const PROJECT_ROOT: string;
+export declare const rseVersion = "1.7.4";
+export declare const rseName = "@reliverse/rse";
+export declare const tsconfigJson = "tsconfig.json";
+export declare const cliConfigJsonc = ".config/rse.jsonc";
+export declare const cliConfigJsoncTmp = ".config/rse.jsonc.tmp";
+export declare const cliConfigJsoncBak = "rse.jsonc.bak";
+export declare const cliConfigTs = ".config/rse.ts";
+export declare const cliConfigTsTmp = ".config/rse.ts.tmp";
+export declare const cliConfigTsBak = "rse.ts.bak";
+export declare const rseOrg = "https://reliverse.org";
+export declare const rseOrgBase = "reliverse.org";
+export declare const cliDomainRoot = "https://docs.reliverse.org";
+export declare const cliDomainDocs = "https://docs.reliverse.org/cli";
+export declare const cliDomainEnv = "https://docs.reliverse.org/env";
+export declare const homeDir: any;
+export declare const cliHomeDir: string;
+export declare const cliHomeTmp: string;
+export declare const cliHomeRepos: string;
+export declare const memoryPath: string;
+export declare const cliJsrPath: string;
+export declare const useLocalhost = false;
+export declare const DEFAULT_CLI_USERNAME = "johnny911";
+export declare const endTitle = "\uD83D\uDCDA Check the docs to learn more: https://docs.reliverse.org/cli";
+export declare const UNKNOWN_VALUE = "unknown";
+export declare const DEFAULT_DOMAIN = "https://example.com";
+export declare const RSE_SCHEMA_DEV = "./schema.json";
+export declare const RSE_SCHEMA_URL = "https://reliverse.org/schema.json";
+export declare const FALLBACK_ENV_EXAMPLE_URL = "https://raw.githubusercontent.com/blefnk/relivator/main/.env.example";
+export declare const CONFIG_CATEGORIES: {
+    readonly core: readonly [".config/rse.jsonc", ".config/rse.ts"];
+    readonly linting: readonly ["biome.json"];
+    readonly ide: readonly [".vscode/settings.json"];
+    readonly git: readonly [".gitignore"];
+};

package/bin/libs/cfg/rse/rse-impl/rse-consts.js

@@ -0,0 +1,37 @@
+import path from "@reliverse/pathkit";
+import os from "node:os";
+export const PROJECT_ROOT = path.resolve(process.cwd());
+export const rseVersion = "1.7.4";
+export const rseName = "@reliverse/rse";
+export const tsconfigJson = "tsconfig.json";
+export const cliConfigJsonc = ".config/rse.jsonc";
+export const cliConfigJsoncTmp = ".config/rse.jsonc.tmp";
+export const cliConfigJsoncBak = "rse.jsonc.bak";
+export const cliConfigTs = ".config/rse.ts";
+export const cliConfigTsTmp = ".config/rse.ts.tmp";
+export const cliConfigTsBak = "rse.ts.bak";
+export const rseOrg = "https://reliverse.org";
+export const rseOrgBase = "reliverse.org";
+export const cliDomainRoot = "https://docs.reliverse.org";
+export const cliDomainDocs = "https://docs.reliverse.org/cli";
+export const cliDomainEnv = "https://docs.reliverse.org/env";
+export const homeDir = os.homedir();
+export const cliHomeDir = path.join(homeDir, ".reliverse");
+export const cliHomeTmp = path.join(cliHomeDir, "temp");
+export const cliHomeRepos = path.join(cliHomeDir, "repos");
+export const memoryPath = path.join(cliHomeDir, "memory.db");
+export const cliJsrPath = path.join(cliHomeDir, "cli");
+export const useLocalhost = false;
+export const DEFAULT_CLI_USERNAME = "johnny911";
+export const endTitle = `\u{1F4DA} Check the docs to learn more: ${cliDomainDocs}`;
+export const UNKNOWN_VALUE = "unknown";
+export const DEFAULT_DOMAIN = "https://example.com";
+export const RSE_SCHEMA_DEV = "./schema.json";
+export const RSE_SCHEMA_URL = `${rseOrg}/schema.json`;
+export const FALLBACK_ENV_EXAMPLE_URL = "https://raw.githubusercontent.com/blefnk/relivator/main/.env.example";
+export const CONFIG_CATEGORIES = {
+  core: [cliConfigJsonc, cliConfigTs],
+  linting: ["biome.json"],
+  ide: [".vscode/settings.json"],
+  git: [".gitignore"]
+};

package/bin/libs/cfg/rse/rse-impl/rse-content.d.ts

@@ -0,0 +1,14 @@
+export interface RequiredProjectContent {
+    fileRseConfig: boolean;
+    filePackageJson: boolean;
+}
+/**
+ * Gets information about the project content, separating required and optional elements.
+ */
+export declare function getProjectContent(projectPath: string): Promise<{
+    requiredContent: RequiredProjectContent;
+    optionalContent: {
+        dirNodeModules: boolean;
+        dirGit: boolean;
+    };
+}>;

package/bin/libs/cfg/rse/rse-impl/rse-content.js

@@ -0,0 +1,15 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { cliConfigJsonc, cliConfigTs } from "./rse-consts.js";
+export async function getProjectContent(projectPath) {
+  const configJSONC = path.join(projectPath, cliConfigJsonc);
+  const configTS = path.join(projectPath, cliConfigTs);
+  const fileRseConfig = await fs.pathExists(configJSONC) || await fs.pathExists(configTS);
+  const filePackageJson = await fs.pathExists(path.join(projectPath, "package.json"));
+  const dirNodeModules = await fs.pathExists(path.join(projectPath, "node_modules"));
+  const dirGit = await fs.pathExists(path.join(projectPath, ".git"));
+  return {
+    requiredContent: { fileRseConfig, filePackageJson },
+    optionalContent: { dirNodeModules, dirGit }
+  };
+}

package/bin/libs/cfg/rse/rse-impl/rse-core.d.ts

@@ -0,0 +1,14 @@
+import type { RseConfig } from "./rse-types";
+/**
+ * Retrieves or creates the main rseg (and any 'mrse' configs).
+ * Allows an optional custom path to the TS config file.
+ */
+export declare function getOrCreateRseConfig({ projectPath, isDev, overrides, customTsconfigPath, }: {
+    projectPath: string;
+    isDev: boolean;
+    overrides: Partial<RseConfig>;
+    customTsconfigPath?: string;
+}): Promise<{
+    config: RseConfig;
+    mrse: RseConfig[];
+}>;

package/bin/libs/cfg/rse/rse-impl/rse-core.js

@@ -0,0 +1,63 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { UNKNOWN_VALUE, RSE_SCHEMA_DEV, cliConfigJsonc, cliConfigTs } from "./rse-consts.js";
+import { createRseConfig } from "./rse-create.js";
+import { DEFAULT_CONFIG_RSE } from "./rse-default.js";
+import { getRseConfigPath } from "./rse-path.js";
+import { readRseConfig } from "./rse-read.js";
+import { parseAndFixRseConfig } from "./rse-repair.js";
+export async function getOrCreateRseConfig({
+  projectPath,
+  isDev,
+  overrides,
+  customTsconfigPath
+}) {
+  const githubUsername = UNKNOWN_VALUE;
+  const mrseFolderPath = path.join(projectPath, ".config", "mrse");
+  const results = [];
+  if (await fs.pathExists(mrseFolderPath)) {
+    const dirItems = await fs.readdir(mrseFolderPath);
+    const rseFiles = dirItems.filter((item) => item === cliConfigJsonc || item === cliConfigTs);
+    const configs = await Promise.all(
+      rseFiles.map(async (file) => {
+        const filePath = path.join(mrseFolderPath, file);
+        let foundConfig = await readRseConfig(filePath, isDev);
+        if (!foundConfig) {
+          foundConfig = await parseAndFixRseConfig(filePath, isDev);
+        }
+        if (!foundConfig) {
+          relinka("warn", `Skipping invalid config file: ${filePath}`);
+        }
+        return foundConfig;
+      })
+    );
+    results.push(...configs.filter((cfg) => cfg !== null));
+  }
+  const { configPath } = await getRseConfigPath(projectPath, isDev, false, customTsconfigPath);
+  if (!await fs.pathExists(configPath)) {
+    await createRseConfig(projectPath, githubUsername, isDev, overrides);
+  } else {
+    const content = (await fs.readFile(configPath, "utf-8")).trim();
+    if (!content || content === "{}") {
+      await createRseConfig(projectPath, githubUsername, isDev, overrides);
+    } else {
+      const validConfig = await readRseConfig(configPath, isDev);
+      if (!validConfig) {
+        const fixed = await parseAndFixRseConfig(configPath, isDev);
+        if (!fixed) {
+          relinka("warn", "Could not fix existing config. Using fallback defaults.");
+        }
+      }
+    }
+  }
+  const mainConfig = await readRseConfig(configPath, isDev);
+  if (!mainConfig) {
+    relinka("warn", "Using fallback default config due to validation failure.");
+    return { config: { ...DEFAULT_CONFIG_RSE }, mrse: results };
+  }
+  if (isDev) {
+    mainConfig.$schema = RSE_SCHEMA_DEV;
+  }
+  return { config: mainConfig, mrse: results };
+}

package/bin/libs/cfg/rse/rse-impl/rse-create.d.ts

@@ -0,0 +1,36 @@
+import type { DeploymentService } from "./rse-types";
+import type { RseConfig } from "./rse-types";
+/**
+ * Writes the given rseConfig to the specified config file (TypeScript or JSONC).
+ * Performs an atomic write (using a temp file) and creates a backup of any existing config.
+ * In dev mode, automatically builds a relative path to `sdk-mod.ts`.
+ */
+export declare function writeRseConfig(configPath: string, config: RseConfig, isDev: boolean, skipInstallPrompt?: boolean, customPathToTypes?: string): Promise<void>;
+/**
+ * rse Config Creation (wrapper around config generator and fixer)
+ */
+export declare function createRseConfig(projectPath: string, githubUsername: string, isDev: boolean, overrides: Partial<RseConfig>): Promise<void>;
+/**
+ * Generates a rse config (rseConfig) by merging defaults, existing config, and overrides.
+ * Writes the resulting config to disk (TypeScript or JSONC), optionally skipping install prompts in non-dev mode.
+ */
+export declare function generateRseConfig({ projectName, frontendUsername, deployService, primaryDomain, projectPath, githubUsername, enableI18n, overwrite, isDev, configInfo, customOutputPath, customFilename, skipInstallPrompt, customPathToTypes, overrides, }: {
+    projectName: string;
+    frontendUsername: string;
+    deployService: DeploymentService;
+    primaryDomain: string;
+    projectPath: string;
+    githubUsername: string;
+    enableI18n?: boolean;
+    overwrite?: boolean;
+    isDev: boolean;
+    configInfo?: {
+        configPath: string;
+        isTS: boolean;
+    };
+    customOutputPath?: string;
+    customFilename?: string;
+    skipInstallPrompt?: boolean;
+    customPathToTypes?: string;
+    overrides: Partial<RseConfig>;
+}): Promise<void>;