@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-deploy.js

@@ -1,151 +0,0 @@
-import { relinka, relinkaAsync } from "@reliverse/relinka";
-import { deploymentsCreateDeployment } from "@vercel/sdk/funcs/deploymentsCreateDeployment";
-import { deploymentsGetDeployment } from "@vercel/sdk/funcs/deploymentsGetDeployment";
-import { deploymentsGetDeploymentEvents } from "@vercel/sdk/funcs/deploymentsGetDeploymentEvents";
-import { simpleGit } from "simple-git";
-import { withRateLimit } from "./vercel-api.js";
-import { getPrimaryVercelTeam } from "./vercel-team.js";
-export async function monitorDeployment(vercelInstance, deploymentId, teamId, slug, showDetailedLogs = false) {
-  try {
-    const logsRes = await deploymentsGetDeploymentEvents(vercelInstance, {
-      idOrUrl: deploymentId,
-      teamId,
-      slug
-    });
-    if (!logsRes.ok) throw logsRes.error;
-    const logs = logsRes.value;
-    if (Array.isArray(logs)) {
-      let errors = 0;
-      let warnings = 0;
-      for (const log of logs) {
-        const timestamp = new Date(log.created).toLocaleTimeString();
-        const message = `[${log.type}] ${log.text}`;
-        if (log.type === "error") {
-          errors++;
-          relinka("error", `${timestamp}: ${message}`);
-        } else if (log.type === "warning") {
-          warnings++;
-          relinka("warn", `${timestamp}: ${message}`);
-        } else if (showDetailedLogs) {
-          relinka("info", `${timestamp}: ${message}`);
-        }
-      }
-      if (errors > 0 || warnings > 0) {
-        relinka("info", `Deployment summary: ${errors} errors, ${warnings} warnings`);
-      }
-    }
-  } catch (error) {
-    relinka(
-      "error",
-      "Error monitoring deployment:",
-      error instanceof Error ? error.message : String(error)
-    );
-  }
-}
-export async function createInitialVercelDeployment(githubInstance, vercelInstance, projectId, memory, projectName, config, selectedOptions, githubUsername, githubToken) {
-  if (!githubToken) {
-    throw new Error(
-      "GitHub token not found in rse's memory. Please restart the CLI and try again. Notify the Reliverse developers if the problem persists."
-    );
-  }
-  relinka("info", "Creating the initial deployment...");
-  relinka("verbose", "Using Vercel deployment config:", JSON.stringify(config));
-  const vercelTeam = await getPrimaryVercelTeam(vercelInstance, memory);
-  if (!vercelTeam) throw new Error("No Vercel team found.");
-  const teamId = vercelTeam.id;
-  const slug = vercelTeam.slug;
-  const git = simpleGit();
-  let commitSha;
-  try {
-    commitSha = await git.revparse(["HEAD"]);
-  } catch (error) {
-    throw new Error(`Failed to get local commit SHA. Ensure the repository is not empty. ${error}`);
-  }
-  let numericRepoId;
-  try {
-    const repoResp = await githubInstance.rest.repos.get({
-      owner: githubUsername,
-      repo: projectName
-    });
-    numericRepoId = repoResp.data.id;
-  } catch (error) {
-    throw new Error(`Failed to fetch GitHub repository numeric ID. ${error}`);
-  }
-  const deploymentRes = await withRateLimit(
-    async () => await deploymentsCreateDeployment(vercelInstance, {
-      teamId,
-      slug,
-      requestBody: {
-        name: projectName,
-        target: "production",
-        project: projectId,
-        gitSource: {
-          type: "github",
-          ref: "main",
-          repoId: numericRepoId,
-          sha: commitSha
-        }
-      }
-    })
-  );
-  if (!deploymentRes.ok) throw deploymentRes.error;
-  const deployment = deploymentRes.value;
-  if (!deployment?.id || !deployment.readyState || !deployment.url) {
-    throw new Error("Failed to create deployment: invalid response from Vercel");
-  }
-  const inProgressStates = ["BUILDING", "INITIALIZING", "QUEUED"];
-  const deploymentUrl = slug ? `https://vercel.com/${slug}/${projectName}/${deployment.id}` : "https://vercel.com";
-  relinka(
-    "info",
-    `Deployment started. To monitor progress, visit: ${deploymentUrl}`,
-    "Status messages will appear every 10 seconds."
-  );
-  let lastMessageTime = Date.now();
-  let status = deployment.readyState;
-  while (inProgressStates.includes(status)) {
-    await monitorDeployment(
-      vercelInstance,
-      deployment.id,
-      teamId,
-      slug,
-      selectedOptions.includes("monitoring")
-    );
-    await new Promise((resolve) => setTimeout(resolve, 5e3));
-    const depRes = await withRateLimit(
-      async () => await deploymentsGetDeployment(vercelInstance, {
-        idOrUrl: deployment.id,
-        teamId,
-        slug
-      })
-    );
-    if (!depRes.ok) throw depRes.error;
-    status = depRes.value.readyState;
-    const now = Date.now();
-    if (now - lastMessageTime >= 1e4) {
-      await relinkaAsync("info", `Deployment status: ${status}`, void 0, void 0, {
-        delay: 50,
-        useSpinner: true,
-        spinnerDelay: 50
-      });
-      lastMessageTime = now;
-    }
-  }
-  if (status !== "READY") {
-    await monitorDeployment(
-      vercelInstance,
-      deployment.id,
-      teamId,
-      slug,
-      selectedOptions.includes("monitoring")
-    );
-    throw new Error(`Deployment failed with status: ${status}`);
-  }
-  await monitorDeployment(
-    vercelInstance,
-    deployment.id,
-    teamId,
-    slug,
-    selectedOptions.includes("monitoring")
-  );
-  return { url: deployment.url, id: deployment.id };
-}

package/bin/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-domain.d.ts

@@ -1,5 +0,0 @@
-import type { InstanceVercel } from "../../../../../utils/instanceVercel.js";
-export declare function getVercelProjectDomain(vercelInstance: InstanceVercel, vercelToken: string, projectName: string): Promise<{
-    domains: string[];
-    primary: string;
-}>;

package/bin/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-domain.js

@@ -1,44 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { projectsGetProjectDomains } from "@vercel/sdk/funcs/projectsGetProjectDomains";
-export async function getVercelProjectDomain(vercelInstance, vercelToken, projectName) {
-  try {
-    if (!vercelToken) {
-      throw new Error("No Vercel token provided");
-    }
-    const res = await projectsGetProjectDomains(vercelInstance, {
-      idOrName: projectName
-    });
-    if (!res.ok) {
-      throw res.error;
-    }
-    const { domains } = res.value;
-    const defaultDomain = `${projectName}.vercel.app`;
-    if (!Array.isArray(domains) || domains.length === 0) {
-      return { domains: [defaultDomain], primary: defaultDomain };
-    }
-    const validDomains = domains.filter((domain) => domain?.name).map((domain) => domain.name);
-    const domainMap = /* @__PURE__ */ new Map();
-    validDomains.forEach((domain) => {
-      const baseDomain = domain.startsWith("www.") ? domain.slice(4) : domain;
-      const group = domainMap.get(baseDomain) ?? [];
-      group.push(domain);
-      domainMap.set(baseDomain, group);
-    });
-    const effectiveDomains = Array.from(domainMap.values()).map((group) => {
-      const nonWww = group.find((d) => !d.startsWith("www."));
-      return nonWww ?? group[0];
-    }).filter((domain) => domain !== void 0);
-    return {
-      domains: effectiveDomains,
-      primary: effectiveDomains[0] ?? defaultDomain
-    };
-  } catch (error) {
-    relinka(
-      "warn",
-      "Failed to get Vercel domain:",
-      error instanceof Error ? error.message : String(error)
-    );
-    const defaultDomain = `${projectName}.vercel.app`;
-    return { domains: [defaultDomain], primary: defaultDomain };
-  }
-}

package/bin/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-env.d.ts

@@ -1,3 +0,0 @@
-import type { InstanceVercel } from "../../../../../utils/instanceVercel.js";
-import type { DeploymentOptions } from "./vercel-types";
-export declare function addEnvVarsToVercelProject(vercelInstance: InstanceVercel, projectName: string, projectPath: string, selectedOptions: DeploymentOptions): Promise<void>;

package/bin/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-env.js

@@ -1,58 +0,0 @@
-import { re } from "@reliverse/relico";
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt } from "@reliverse/rempts";
-import { projectsCreateProjectEnv } from "@vercel/sdk/funcs/projectsCreateProjectEnv";
-import { getVercelEnvVar, withRateLimit } from "./vercel-api.js";
-import { getEnvVars } from "./vercel-utils.js";
-export async function addEnvVarsToVercelProject(vercelInstance, projectName, projectPath, selectedOptions) {
-  relinka("info", "Setting up environment variables...");
-  const envVars = await getEnvVars(projectPath);
-  if (envVars.length === 0) {
-    return;
-  }
-  if (selectedOptions.useSharedEnvVars) {
-    const shouldUseShared = await confirmPrompt({
-      title: `Would you like to use shared environment variables from Vercel.com? ${re.red("[\u{1F6A8} Experimental]")}`,
-      content: "Only missing variables will be uploaded from your local .env file",
-      defaultValue: false
-    });
-    if (shouldUseShared) {
-      const existingEnvVars = await getVercelEnvVar(
-        vercelInstance,
-        projectName,
-        envVars[0]?.key ?? ""
-      );
-      const newEnvVars = envVars.filter((env) => !existingEnvVars?.key.includes(env.key));
-      if (newEnvVars.length > 0) {
-        await uploadEnvVars(vercelInstance, projectName, newEnvVars);
-        relinka("success", `Added ${newEnvVars.length} new environment variables`);
-        if (existingEnvVars) {
-          relinka("info", `Kept ${existingEnvVars.key} existing shared variables`);
-        }
-      } else {
-        relinka("info", "All required environment variables are already set in Vercel");
-      }
-    } else {
-      await uploadEnvVars(vercelInstance, projectName, envVars);
-      relinka("verbose", "Environment variables added successfully");
-    }
-  } else {
-    await uploadEnvVars(vercelInstance, projectName, envVars);
-    relinka("verbose", "Environment variables added successfully");
-  }
-}
-async function uploadEnvVars(vercelInstance, projectName, envVars) {
-  await withRateLimit(async () => {
-    const res = await projectsCreateProjectEnv(vercelInstance, {
-      idOrName: projectName,
-      upsert: "true",
-      requestBody: envVars.map((env) => ({
-        ...env,
-        target: env.target ?? ["production", "preview", "development"]
-      }))
-    });
-    if (!res.ok) {
-      throw res.error;
-    }
-  });
-}

package/bin/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-team.d.ts

@@ -1,15 +0,0 @@
-import type { InstanceVercel } from "../../../../../utils/instanceVercel.js";
-export interface VercelTeam {
-    id: string;
-    slug: string;
-    name: string;
-}
-/**
- * Gets the primary Vercel team details from memory or verifies and returns from API
- */
-export declare function getPrimaryVercelTeam(vercelInstance: InstanceVercel, memory: {
-    vercelTeamId?: string;
-    vercelTeamSlug?: string;
-}): Promise<VercelTeam | undefined>;
-export declare function verifyTeam(vercelInstance: InstanceVercel, teamId: string, teamSlug: string): Promise<boolean>;
-export declare function getVercelTeams(vercelInstance: InstanceVercel): Promise<VercelTeam[]>;

package/bin/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-team.js

@@ -1,74 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { teamsGetTeam } from "@vercel/sdk/funcs/teamsGetTeam";
-import { teamsGetTeams } from "@vercel/sdk/funcs/teamsGetTeams";
-import { getOrCreateReliverseMemory } from "../../../../../utils/reliverseMemory.js";
-export async function getPrimaryVercelTeam(vercelInstance, memory) {
-  try {
-    if (memory.vercelTeamId && memory.vercelTeamSlug) {
-      const isTeamValid = await verifyTeam(
-        vercelInstance,
-        memory.vercelTeamId,
-        memory.vercelTeamSlug
-      );
-      if (isTeamValid) {
-        const teams2 = await getVercelTeams(vercelInstance);
-        const memoryTeam = teams2.find((team) => team.id === memory.vercelTeamId);
-        if (memoryTeam) {
-          return memoryTeam;
-        }
-      }
-    }
-    const teams = await getVercelTeams(vercelInstance);
-    if (teams?.length > 0 && teams[0]) {
-      const team = teams[0];
-      memory.vercelTeamId = team.id;
-      memory.vercelTeamSlug = team.slug;
-      await getOrCreateReliverseMemory();
-      return team;
-    }
-    return;
-  } catch (error) {
-    relinka(
-      "warn",
-      "Error getting primary Vercel team:",
-      error instanceof Error ? error.message : String(error)
-    );
-    return;
-  }
-}
-export async function verifyTeam(vercelInstance, teamId, teamSlug) {
-  try {
-    const res = await teamsGetTeam(vercelInstance, {
-      teamId,
-      slug: teamSlug
-    });
-    if (!res.ok) {
-      relinka("warn", "Failed to verify team:", res.error?.message ?? "Unknown error");
-      return false;
-    }
-    return true;
-  } catch (error) {
-    relinka(
-      "warn",
-      "Error verifying team:",
-      error instanceof Error ? error.message : String(error)
-    );
-    return false;
-  }
-}
-export async function getVercelTeams(vercelInstance) {
-  const res = await teamsGetTeams(vercelInstance, {
-    limit: 10
-  });
-  if (!res.ok) {
-    throw res.error;
-  }
-  const { teams } = res.value;
-  return teams.filter(
-    (team) => team.name !== null
-  ).map((team) => ({
-    id: team.id,
-    slug: team.slug,
-    name: team.name
-  }));
-}

package/bin/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-types.d.ts

@@ -1,28 +0,0 @@
-import type { CreateProjectEnv2Target, CreateProjectEnv2Type } from "@vercel/sdk/models/createprojectenvop";
-import type { GetProjectsFramework } from "@vercel/sdk/models/getprojectsop";
-export type VercelFramework = GetProjectsFramework;
-export interface VercelDeploymentConfig {
-    framework: VercelFramework | null;
-    rootDirectory?: string | null;
-    buildCommand?: string | null;
-    outputDirectory?: string | null;
-    devCommand?: string | null;
-    installCommand?: string | null;
-}
-export type DeploymentLogType = "error" | "warning" | "info" | "debug";
-export interface DeploymentLog {
-    type: DeploymentLogType;
-    created: number;
-    text: string;
-}
-export interface EnvVar {
-    key: string;
-    value: string;
-    type: CreateProjectEnv2Type;
-    target?: CreateProjectEnv2Target[];
-}
-export interface DeploymentOptions {
-    options: string[];
-    useSharedEnvVars: boolean;
-    sharedEnvVarsProduction?: boolean;
-}

package/bin/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-utils.d.ts

@@ -1,26 +0,0 @@
-import type { GetProjectsFramework, GetProjectsTarget1 } from "@vercel/sdk/models/getprojectsop";
-import type { InstanceVercel } from "../../../../../utils/instanceVercel.js";
-import type { ReliverseMemory } from "../../../../../utils/schemaMemory.js";
-type VercelFramework = GetProjectsFramework;
-/**
- * Saves token to memory and persists it
- */
-export declare function saveVercelToken(token: string, memory: ReliverseMemory, vercelInstance: InstanceVercel): Promise<void>;
-/**
- * Gets environment variables from .env file
- */
-export declare function getEnvVars(projectPath: string): Promise<{
-    key: string;
-    value: string;
-    target: GetProjectsTarget1[];
-    type: "plain" | "encrypted" | "sensitive";
-}[]>;
-/**
- * Detects the project framework
- */
-export declare function detectFramework(directory: string): Promise<VercelFramework>;
-/**
- * Verifies domain configuration.
- */
-export declare function verifyDomain(vercelInstance: InstanceVercel, projectId: string, domain: string): Promise<boolean>;
-export {};

package/bin/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-utils.js

@@ -1,134 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { selectPrompt } from "@reliverse/rempts";
-import { projectsGetProjectDomain } from "@vercel/sdk/funcs/projectsGetProjectDomain";
-import { updateReliverseMemory } from "../../../../../utils/reliverseMemory.js";
-import { getVercelTeams, verifyTeam } from "./vercel-team.js";
-export async function saveVercelToken(token, memory, vercelInstance) {
-  memory.vercelKey = token;
-  const teams = await getVercelTeams(vercelInstance);
-  if (teams && teams.length > 0) {
-    let selectedTeam;
-    if (teams.length === 1 && teams[0]) {
-      selectedTeam = teams[0];
-      relinka("info", `Auto-selected Vercel team with slug: ${selectedTeam.slug}`);
-    } else {
-      const teamChoice = await selectPrompt({
-        title: "Select a Vercel team:",
-        options: teams.map((team) => ({
-          value: team.id,
-          label: team.name,
-          hint: team.slug
-        }))
-      });
-      selectedTeam = teams.find((team) => team.id === teamChoice);
-    }
-    const isTeamValid = await verifyTeam(vercelInstance, selectedTeam.id, selectedTeam.slug);
-    if (isTeamValid) {
-      await updateReliverseMemory({
-        vercelTeamId: selectedTeam.id,
-        vercelTeamSlug: selectedTeam.slug
-      });
-    } else {
-      relinka("error", "Failed to verify Vercel team details. Vercel team will not be saved.");
-      await updateReliverseMemory({
-        vercelTeamId: "",
-        vercelTeamSlug: ""
-      });
-    }
-  } else {
-    await updateReliverseMemory({
-      vercelTeamId: "",
-      vercelTeamSlug: ""
-    });
-  }
-  relinka("success", "Vercel token saved successfully!");
-}
-export async function getEnvVars(projectPath) {
-  const envFile = path.join(projectPath, ".env");
-  const envVars = [];
-  if (await fs.pathExists(envFile)) {
-    const content = await fs.readFile(envFile, "utf-8");
-    const lines = content.split("\n");
-    for (const line of lines) {
-      const [key, ...valueParts] = line.trim().split("=");
-      if (key && !key.startsWith("#")) {
-        const value = valueParts.join("=").trim().replace(/^["']|["']$/g, "");
-        if (!value || value === '""' || value === "''") {
-          continue;
-        }
-        const targets = key.startsWith("NEXT_PUBLIC_") ? ["production", "preview", "development"] : key.includes("_PREVIEW_") ? ["preview"] : key.includes("_DEV_") ? ["development"] : ["production"];
-        const type = !key.startsWith("NEXT_PUBLIC_") && (key.includes("SECRET") || key.includes("KEY") || key.includes("TOKEN") || key.includes("PASSWORD") || key.includes("CREDENTIAL") || key.includes("PRIVATE") || /^[A-Fa-f0-9]{32,}$/.test(value)) ? "encrypted" : "plain";
-        envVars.push({
-          key,
-          value,
-          target: targets,
-          type
-        });
-      }
-    }
-  }
-  return envVars;
-}
-export async function detectFramework(directory) {
-  try {
-    const packageJsonPath = path.join(directory, "package.json");
-    if (await fs.pathExists(packageJsonPath)) {
-      const packageJson = await fs.readJson(packageJsonPath);
-      const { dependencies = {}, devDependencies = {} } = packageJson;
-      const allDeps = { ...dependencies, ...devDependencies };
-      if (allDeps.next) return "nextjs";
-      if (allDeps.nuxt) return "nuxtjs";
-      if (allDeps["@sveltejs/kit"]) return "sveltekit";
-      if (allDeps.astro) return "astro";
-      if (allDeps.gatsby) return "gatsby";
-      if (allDeps.remix) return "remix";
-      if (allDeps.vue) return "vue";
-      if (allDeps.react) return "create-react-app";
-      if (allDeps["@angular/core"]) return "angular";
-      if (allDeps.svelte) return "svelte";
-      if (allDeps.vite) return "vite";
-    }
-    const files = await fs.readdir(directory);
-    if (files.includes("astro.config.mjs") || files.includes("astro.config.ts")) return "astro";
-    if (files.includes("nuxt.config.js") || files.includes("nuxt.config.ts")) return "nuxtjs";
-    if (files.includes("svelte.config.js")) return "sveltekit";
-    if (files.includes("gatsby-config.js")) return "gatsby";
-    if (files.includes("remix.config.js")) return "remix";
-    if (files.includes("next.config.js") || files.includes("next.config.mjs") || files.includes("next.config.ts"))
-      return "nextjs";
-    if (files.includes("vite.config.js") || files.includes("vite.config.ts")) return "vite";
-    return "nextjs";
-  } catch (_error) {
-    relinka("warn", "Failed to detect framework, defaulting to Next.js");
-    return "nextjs";
-  }
-}
-export async function verifyDomain(vercelInstance, projectId, domain) {
-  try {
-    const res = await projectsGetProjectDomain(vercelInstance, {
-      idOrName: projectId,
-      domain
-    });
-    if (!res.ok) {
-      throw res.error;
-    }
-    const domainResponse = res.value;
-    if (domainResponse.verification && domainResponse.verification.length > 0) {
-      relinka("info", "Domain verification required. Please add the following DNS records:");
-      for (const record of domainResponse.verification) {
-        relinka("info", `Type: ${record.type}, Value: ${record.value}`);
-      }
-      return false;
-    }
-    return domainResponse.verified;
-  } catch (error) {
-    relinka(
-      "error",
-      "Error verifying domain:",
-      error instanceof Error ? error.message : String(error)
-    );
-    return false;
-  }
-}

package/bin/impl/inject/inject-impl-mod.d.ts

@@ -1,112 +0,0 @@
-export interface InjectionLocation {
-    line: number;
-    column?: number;
-}
-export interface SingleInjection {
-    filePath: string;
-    location?: InjectionLocation;
-    content: string | string[];
-    injectBefore?: string | string[];
-    injectAfter?: string | string[];
-}
-export interface InjectionResult {
-    success: boolean;
-    filePath: string;
-    location?: InjectionLocation;
-    injectBefore?: string | string[];
-    injectAfter?: string | string[];
-    error?: string;
-    code?: string;
-    hasChanged?: boolean;
-    /**
-     * TODO: format results as {"path/to/file1": {}, "path/to/file2": {}} instead of [{filePath: "path/to/file1", ...}, {filePath: "path/to/file2", ...}]
-     *
-     * TODO: matchesFound will be more useful in this case (because currently we always have 1 matchFound for each injection)
-     */
-    matchesFound?: number;
-}
-export interface InjectionOptions {
-    generateSourceMap?: boolean;
-    sourceMapPath?: string;
-    preserveOriginal?: boolean;
-    writeToFile?: boolean;
-    revert?: boolean;
-    based?: "0-based" | "1-based";
-    logCode?: boolean;
-    strict?: boolean;
-    arrayBeforeAfter?: "array-means-multiline" | "append-to-each-element";
-}
-/**
- * Injects or reverts content at a specific location in a single file
- */
-export declare const injectAtLocation: (injection: SingleInjection, options?: InjectionOptions) => Promise<InjectionResult>;
-/**
- * Injects or reverts content at multiple locations across multiple files
- * Processes injections efficiently by grouping by file
- *
- * Supports automatic line-offset handling:
- * Whenever an earlier injection adds newline characters, subsequent
- * location-based injections will transparently subtract the cumulative
- * newline count so users can keep writing “line: N” without manual fixes.
- */
-export declare const injectMultiple: (injections: SingleInjection[], options?: InjectionOptions) => Promise<InjectionResult[]>;
-/**
- * Creates a single injection object with validation
- */
-export declare const createInjection: (filePath: string, content: string | string[], positioning: {
-    line: number;
-    column?: number;
-} | {
-    injectBefore: string | string[];
-} | {
-    injectAfter: string | string[];
-}) => SingleInjection;
-/**
- * Validates a single injection configuration
- */
-export declare const validateInjection: (injection: SingleInjection, based?: "0-based" | "1-based") => string | null;
-/**
- * Batch validates multiple injections
- */
-export declare const validateMultipleInjections: (injections: SingleInjection[], based?: "0-based" | "1-based") => {
-    index: number;
-    error: string;
-}[];
-/**
- * Preview injection without writing to file
- */
-export declare const previewInjection: (injection: SingleInjection, options?: Omit<InjectionOptions, "writeToFile">) => Promise<InjectionResult>;
-/**
- * Preview multiple injections without writing to files
- */
-export declare const previewMultipleInjections: (injections: SingleInjection[], options?: Omit<InjectionOptions, "writeToFile">) => Promise<InjectionResult[]>;
-/**
- * Preview revert operation without writing to file
- */
-export declare const previewRevert: (injection: SingleInjection, options?: Omit<InjectionOptions, "writeToFile" | "revert">) => Promise<InjectionResult>;
-/**
- * Preview multiple revert operations without writing to files
- */
-export declare const previewMultipleReverts: (injections: SingleInjection[], options?: Omit<InjectionOptions, "writeToFile" | "revert">) => Promise<InjectionResult[]>;
-declare const _default: {
-    injectAtLocation: (injection: SingleInjection, options?: InjectionOptions) => Promise<InjectionResult>;
-    injectMultiple: (injections: SingleInjection[], options?: InjectionOptions) => Promise<InjectionResult[]>;
-    createInjection: (filePath: string, content: string | string[], positioning: {
-        line: number;
-        column?: number;
-    } | {
-        injectBefore: string | string[];
-    } | {
-        injectAfter: string | string[];
-    }) => SingleInjection;
-    validateInjection: (injection: SingleInjection, based?: "0-based" | "1-based") => string | null;
-    validateMultipleInjections: (injections: SingleInjection[], based?: "0-based" | "1-based") => {
-        index: number;
-        error: string;
-    }[];
-    previewInjection: (injection: SingleInjection, options?: Omit<InjectionOptions, "writeToFile">) => Promise<InjectionResult>;
-    previewMultipleInjections: (injections: SingleInjection[], options?: Omit<InjectionOptions, "writeToFile">) => Promise<InjectionResult[]>;
-    previewRevert: (injection: SingleInjection, options?: Omit<InjectionOptions, "writeToFile" | "revert">) => Promise<InjectionResult>;
-    previewMultipleReverts: (injections: SingleInjection[], options?: Omit<InjectionOptions, "writeToFile" | "revert">) => Promise<InjectionResult[]>;
-};
-export default _default;