@bepack/cli 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,618 @@
+//#region src/utils/npmRegistry.d.ts
+declare class NpmRegistryClient {
+  private readonly registry;
+  private readonly logger?;
+  private readonly cache;
+  constructor(registry: string, logger?: LoggerLike | undefined);
+  metadata(packageName: string): Promise<NpmPackageMetadata>;
+  versions(metadata: NpmPackageMetadata): string[];
+  versionsOf(packageName: string): Promise<string[]>;
+  distTag(metadata: NpmPackageMetadata, tag: string): string | undefined;
+  private packageUrl;
+}
+//#endregion
+//#region src/config/configTypes.d.ts
+type CommandName = "init" | "install" | "manifest" | "build" | "dev" | "copy" | "pack" | "config";
+/**
+ * Script API dependency selector.
+ *
+ * - `stable`: resolve a concrete stable npm version from registry.
+ * - `beta`: resolve a concrete beta npm version from registry.
+ * - exact version: use the version as-is.
+ */
+type DependencySpecifier = "stable" | "beta" | string;
+/** Where BePack writes managed npm dependencies in package.json. */
+type SaveTo = "dependencies" | "devDependencies";
+/** Package manager used by `bepack install` after package.json is patched. */
+type PackageManager = "auto" | "npm" | "pnpm" | "yarn" | "bun";
+/** Copy behavior used by build/dev. `true` means copy.defaultTarget. */
+type CopySetting = false | true | string;
+/** Rolldown external dependency matcher. */
+type BuildExternal = string | RegExp;
+/** A replacement value, resolved against the normalized BePack config. */
+type ReplaceValue = string | ((config: ResolvedConfig) => string);
+type ReplaceBuiltins = {
+  VERSION?: boolean;
+  NAME?: boolean;
+  UUID?: boolean;
+  DESCRIPTION?: boolean;
+};
+type ReplaceOptions = {
+  /** Replacement tokens and their literal or config-aware values. */
+  values?: Record<string, ReplaceValue>;
+  /** Enable replacement of BePack's built-in tokens. Disabled by default. */
+  builtins?: ReplaceBuiltins;
+};
+type LoggerLike = {
+  info(message: string): void;
+  warn(message: string): void;
+  error(message: string): void;
+  verbose(message: string): void;
+  clear(): void;
+  install?(message: string): void;
+};
+/** Manifest fields for one concrete version in an npm package document. */
+type NpmPackageVersionMetadata = {
+  dependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+};
+/** npm registry package document fields exposed to dependency resolver plugins. */
+type NpmPackageMetadata = {
+  "dist-tags"?: Record<string, string>;
+  versions?: Record<string, NpmPackageVersionMetadata>;
+};
+type DependencyCatalogEntry = {
+  /** Resolver used for this dependency. Can be a resolver name string or a direct DependencyResolverRule reference. */
+  resolver: string | DependencyResolverRule;
+  /** Whether to write to bp manifest.json dependencies. When true, the dependency is also externalized during build. Defaults to false. */
+  manifest?: boolean;
+};
+type DependencyResolverResult = {
+  /** Concrete npm version written to package.json. */
+  packageVersion: string;
+  /** Version written to manifest.json. Use null for package-only dependencies. */
+  manifestVersion?: string | null;
+};
+type DependencyResolveHookContext = {
+  packageName: string;
+  specifier: string;
+  target: string;
+  entry: DependencyCatalogEntry;
+  config: ResolvedConfig;
+};
+type DependencyResolvedHookContext = DependencyResolveHookContext & {
+  result: DependencyResolverResult;
+};
+type DependencyResolverContext = {
+  packageName: string;
+  specifier: string;
+  target: string;
+  entry: DependencyCatalogEntry;
+  config: ResolvedConfig;
+  npm: NpmRegistryClient;
+  logger?: LoggerLike;
+};
+type DependencyResolverRule = {
+  /** Human-readable resolver name used for logs/debugging. */
+  name: string;
+  /** Optional resolver group. Package catalog entries can select this by name. */
+  resolver?: string;
+  /** Whether this rule can resolve the dependency. */
+  match(ctx: DependencyResolverContext): boolean;
+  /** Resolve package.json and optional manifest versions. */
+  resolve(ctx: DependencyResolverContext): DependencyResolverResult | Promise<DependencyResolverResult>;
+};
+type HookContext = {
+  command: CommandName;
+  cwd: string;
+  mode?: string;
+  target: string;
+  config: ResolvedConfig;
+  /** Convenience resolved paths. Only includes paths for packs that are configured. */
+  paths: {
+    dist: string;
+    /** BP root directory. Only present when packs.bp is configured. */
+    bpRoot?: string;
+    /** RP root directory. Only present when packs.rp is configured. */
+    rpRoot?: string;
+    /** BP manifest path. Only present when packs.bp is configured. */
+    bpManifest?: string;
+    /** RP manifest path. Only present when packs.rp is configured. */
+    rpManifest?: string;
+    /** Compilation entry. Only present when packs.bp?.compile is configured. */
+    srcEntry?: string;
+    /** Compiled script output. Only present when packs.bp?.compile is configured. */
+    scriptOutFile?: string;
+    /** Compiled script output directory. Only present when packs.bp?.compile is configured. */
+    scriptOutDir?: string;
+  };
+  logger: LoggerLike;
+};
+type HookResult = string | number | boolean | null | undefined | Record<string, unknown>;
+type Hooks = Partial<Record<"beforeInstall" | "afterInstall" | "beforeManifest" | "afterManifest" | "beforeBuild" | "afterBuild" | "beforeCopy" | "afterCopy" | "beforePack" | "afterPack", (ctx: HookContext) => HookResult | Promise<HookResult>>>;
+type ConfigResolvedHookContext = {
+  cwd: string;
+  config: ResolvedConfig;
+};
+type PluginDependencyHooks = {
+  beforeResolveDependency?: (ctx: DependencyResolveHookContext) => HookResult | Promise<HookResult>;
+  afterResolveDependency?: (ctx: DependencyResolvedHookContext) => HookResult | Promise<HookResult>;
+};
+/**
+ * Extends BePack through `plugins: [plugin()]` in the project config.
+ *
+ * Plugin dependency resolvers are registered before BePack's built-in resolvers.
+ * Add a matching `dependencyCatalog` entry when the plugin manages a package that
+ * is not already in BePack's built-in catalog.
+ */
+type BePackPlugin = {
+  /** Unique, human-readable plugin name used in diagnostics. */
+  name: string;
+  /** Optional plugin metadata for discovery and compatibility checks. */
+  version?: string;
+  description?: string;
+  apiVersion?: 1;
+  /** Higher priorities run/register first; ties preserve the plugins array order. */
+  priority?: number;
+  /** Runs after configuration has been normalized. */
+  configResolved?: (ctx: ConfigResolvedHookContext) => void | Promise<void>;
+  /** Dependency resolution additions supplied by the plugin. */
+  install?: {
+    dependencyCatalog?: Record<string, DependencyCatalogEntry>;
+    dependencyResolvers?: DependencyResolverRule[];
+    hooks?: PluginDependencyHooks;
+  };
+  /** Lifecycle hooks run with the same context as project-level hooks. */
+  hooks?: Hooks;
+};
+type PackConfig = {
+  /** Pack root directory, relative to `root` unless absolute. Example: `bp` or `packs/bp`. */
+  root?: string;
+  /** Header UUID written to manifest.json. */
+  uuid: string;
+  /** Module UUID written to manifest.json.
+   *  For BP: required only when compile is configured (to manage script module).
+   *  For RP: always required (to manage resources module). */
+  moduleUuid?: string;
+  /** Manifest header name. Defaults to top-level `name`. */
+  name?: string;
+  /** Manifest header description. Defaults to top-level `description`. */
+  description?: string;
+};
+/** TypeScript incremental compilation cache settings. */
+type CacheOptions = {
+  /** Use cache in dev mode. Default: true. */
+  dev?: boolean;
+  /** Use cache in build mode. Default: false. */
+  build?: boolean;
+  /** Path to .tsbuildinfo file (relative to project root). */
+  file?: string;
+};
+type CacheResolved = {
+  dev: boolean;
+  build: boolean;
+  file: string;
+};
+/** BP compile configuration. Only available on behavior packs. */
+type BpCompileOptions = {
+  /** Script entry file, relative to project root. Default: "src/main.ts". */
+  entry: string;
+  /** Path to tsconfig.json relative to project root. Default: "tsconfig.json". */
+  tsconfig?: string;
+  /** Whether to run `tsc --noEmit` before rolldown. Default: true. */
+  typecheck?: boolean;
+  /** Whether rolldown should preserve module files. Default: true. */
+  preserveModules?: boolean;
+  /** Additional packages/modules that Rolldown should not bundle. */
+  external?: BuildExternal[];
+  /** Use `npx tsc --noEmit` instead of system `tsc --noEmit`. Default: false. */
+  useNpx?: boolean;
+  /** Minify output via rolldown. Default: false. */
+  minify?: boolean;
+  /** TypeScript incremental compilation cache settings.
+   *  `dev` defaults to true, `build` defaults to false.
+   *  `file` defaults to "node_modules/.cache/bepack/tsconfig.tsbuildinfo".
+   *  CLI `--cache` / `--no-cache` overrides build mode. */
+  cache?: CacheOptions;
+  /** Output directory for compiled scripts, relative to BP root. Default: "scripts". */
+  scriptOutputDir?: string;
+};
+type BpConfig = PackConfig & {
+  /** BP compile configuration (TypeScript entry, tsconfig, bundler options).
+   *  When set, enables TypeScript compilation and rolldown bundling. */
+  compile?: BpCompileOptions;
+  /** Script API dependencies managed in both package.json and bp/manifest.json. */
+  dependencies?: Record<string, DependencySpecifier>;
+  /** Adds achievement-compatible metadata when every Script API dependency is stable. */
+  achievement?: boolean;
+  /** Additional files/folders to include when copying/packing the behavior pack,
+   * on top of built-in defaults (scripts/, manifest.json, animations/, etc.). */
+  include?: string[];
+};
+type RpConfig = PackConfig & {
+  /** Adds `pbr` capability to the resource pack manifest. */
+  pbr?: boolean;
+  /** Additional files/folders to include when copying/packing the resource pack,
+   * on top of built-in defaults. */
+  include?: string[];
+};
+/** Copy target with explicit bp/rp paths. */
+type CopyTargetCustom = {
+  type: "custom";
+  bp?: string;
+  rp?: string;
+};
+/** Copy target derived from a Minecraft game root directory.
+ *  BP is copied to `<path>/development_behavior_packs`,
+ *  RP is copied to `<path>/development_resource_packs`. */
+type CopyTargetGameRoot = {
+  type: "gameRoot";
+  path: string;
+};
+type CopyTarget = CopyTargetCustom | CopyTargetGameRoot;
+/** Per-target or global copy folder name overrides. Falls back to `packs.bp.name` / `packs.rp.name`. */
+type CopyTargetNames = {
+  bp?: string;
+  rp?: string;
+};
+/** Dev mode watch configuration. */
+type DevWatchConfig = {
+  /** Additional files/directories to watch (relative to cwd), on top of copy include items. */
+  include?: string[];
+};
+type UserConfig = {
+  /** Project root directory. Other relative paths are resolved from here. */
+  root?: string;
+  /** Addon/package name used for manifest defaults and pack output names. */
+  name?: string;
+  /** Addon version. Must be `x.y.z` when written to manifest.json. */
+  version?: string;
+  /** Addon description used as manifest default. */
+  description?: string;
+  /** String replacement performed by Rolldown while compiling BP scripts. */
+  replace?: ReplaceOptions;
+  /** Manifest format version used when writing manifest.json.
+   * - `2`: array versions (e.g. `[1, 0, 0]`). Default for format_version 2 manifests.
+   * - `3`: SemVer string versions (e.g. `"1.0.0"`). All version fields must be strings.
+   * Format 3 does NOT accept array versions — every version must be a string.
+   * When not set, the existing manifest's format_version is preserved.
+   * Default: 2 for new manifests. */
+  manifestFormat?: 2 | 3;
+  target?: string;
+  /** Plugins that add dependency resolution rules and/or lifecycle hooks. */
+  plugins?: Array<BePackPlugin | string>;
+  /** Behavior/resource pack configuration. At least one pack must be configured. */
+  packs?: {
+    /** Behavior pack configuration. Optional. */
+    bp?: BpConfig;
+    /** Resource pack configuration. Optional. */
+    rp?: RpConfig;
+  };
+  /** Dependency install and package manager behavior. */
+  install?: {
+    /** npm registry used for resolving concrete @minecraft versions. */
+    registry?: string;
+    /** Where managed dependencies are written. Defaults to `dependencies`. */
+    saveTo?: SaveTo;
+    /** Package manager to run after patching package.json. */
+    packageManager?: PackageManager;
+    /** Whether to run the package manager after patching package.json. */
+    runPackageManager?: boolean;
+    /** Whether `bepack install` patches package.json. */
+    updatePackageJson?: boolean;
+    /** Whether `bepack install` patches manifest.json. */
+    updateManifest?: boolean;
+    /** Additional managed dependency package definitions. */
+    dependencyCatalog?: Record<string, DependencyCatalogEntry>;
+    /**
+     * Custom dependency resolvers.
+     *
+     * Rules are tried before BePack built-ins, making this a future plugin hook.
+     */
+    dependencyResolvers?: DependencyResolverRule[];
+  };
+  /** Build pipeline configuration — post-build actions only.
+   *  Compilation config (entry, typecheck, bundler options) goes under packs.bp.compile. */
+  build?: {
+    /** Copy after build: false, true for default target, or a target name. */
+    copy?: CopySetting;
+    /** Show per-step timing in build/dev output. Defaults to false. */
+    timing?: boolean;
+  };
+  /** Dev watcher behavior. */
+  dev?: {
+    /** Copy after dev updates: false, true for default target, or a target name. */
+    copy?: CopySetting;
+    /** Watch configuration. Defaults to src entry dir + copy include items. */
+    watch?: DevWatchConfig;
+  };
+  /** Copy targets for `bepack copy` and build/dev copy. */
+  copy?: {
+    /** Default copy target. Built-ins: `win`, `winold`. */
+    defaultTarget?: string;
+    /** Global folder name overrides for all targets. Per-target `name` takes precedence. */
+    name?: string | CopyTargetNames;
+    /** Additional RP files/folders to include when copying.
+     *  @deprecated Use packs.rp.include instead. */
+    include?: {
+      rp?: string[];
+    };
+    /** Custom copy targets. */
+    targets?: Record<string, CopyTarget & {
+      name?: string | CopyTargetNames;
+    }>;
+  };
+  pack?: {
+    /** Output filename template without extension. Supports `{name}` and `{version}`. */
+    name?: string;
+    /** Output directory for .mcpack/.mcaddon, relative to `root` unless absolute. */
+    outDir?: string;
+  };
+  /** Lifecycle hooks. */
+  hooks?: Hooks;
+};
+/** Resolved BP compile configuration (all fields filled with defaults). */
+type BpCompileResolved = {
+  entry: string;
+  tsconfig: string;
+  typecheck: boolean;
+  preserveModules: boolean;
+  external: BuildExternal[];
+  useNpx: boolean;
+  minify: boolean;
+  cache: CacheResolved;
+  scriptOutputDir: string;
+};
+type ResolvedConfig = {
+  root: string;
+  configured: {
+    root: boolean;
+    packOutDir: boolean;
+  };
+  name: string;
+  version: string;
+  description?: string;
+  replace: {
+    values: Record<string, ReplaceValue>;
+    builtins: Required<ReplaceBuiltins>;
+  };
+  target: string;
+  /** Plugins applied while resolving this config. */
+  plugins?: BePackPlugin[];
+  /** Plugin ordering and catalog override diagnostics. */
+  pluginDiagnostics?: string[];
+  manifestFormat?: 2 | 3;
+  hooks: Hooks;
+  packs: {
+    bp?: {
+      root: string;
+      uuid: string;
+      moduleUuid?: string;
+      name: string;
+      description?: string;
+      compile?: BpCompileResolved;
+      dependencies: Record<string, DependencySpecifier>;
+      achievement?: boolean;
+      include: string[];
+    };
+    rp?: {
+      root: string;
+      uuid: string;
+      moduleUuid: string;
+      name: string;
+      description?: string;
+      pbr?: boolean;
+      include: string[];
+    };
+  };
+  install: {
+    registry: string;
+    saveTo: SaveTo;
+    packageManager: PackageManager;
+    runPackageManager: boolean;
+    updatePackageJson: boolean;
+    updateManifest: boolean;
+    dependencyCatalog: Record<string, DependencyCatalogEntry>;
+    dependencyResolvers: DependencyResolverRule[];
+  };
+  build: {
+    copy: CopySetting;
+    timing: boolean;
+  };
+  dev: {
+    copy: CopySetting;
+    watch?: DevWatchConfig;
+  };
+  copy: {
+    defaultTarget: string;
+    /** Global folder name overrides for all targets. Per-target `name` takes precedence. */
+    name?: string | CopyTargetNames;
+    /** @deprecated Use packs.rp.include instead. */
+    include?: {
+      rp?: string[];
+    };
+    targets: Record<string, CopyTarget & {
+      name?: string | CopyTargetNames;
+    }>;
+  };
+  pack: {
+    name: string;
+    outDir: string;
+  };
+};
+type LoadConfigOptions = {
+  cwd: string;
+  configPath?: string;
+  overrides?: Partial<UserConfig>;
+};
+type PackType = "bp" | "rp";
+/** Unified pack info for generic operations (copy, watch, pack, paths). */
+type PackInfo = {
+  type: PackType;
+  root: string;
+  uuid: string;
+  moduleUuid?: string;
+  name: string;
+  include: string[];
+};
+/** Iterate over all configured packs, returning uniform PackInfo objects. */
+declare function getConfiguredPacks(config: ResolvedConfig): PackInfo[];
+//#endregion
+//#region src/config/defaultConfig.d.ts
+declare function defineConfig(config: UserConfig): UserConfig;
+//#endregion
+//#region src/config/loadConfig.d.ts
+declare function loadConfig(options: LoadConfigOptions): Promise<{
+  config: ResolvedConfig;
+  path: string;
+  cwd: string;
+}>;
+//#endregion
+//#region src/manifest/patchManifest.d.ts
+type PatchManifestOptions = {
+  cwd: string;
+  config: ResolvedConfig;
+  dryRun?: boolean;
+  resolvedDeps?: Record<string, string>;
+  logger?: LoggerLike;
+};
+/**
+ * 修补 BP 和/或 RP manifest 文件。
+ *
+ * - 只负责任务编排：路径计算、文件读写、调用构建器和依赖管理器。
+ * - 如果 manifest 已存在，保留用户手写字段并覆盖 BePack 管理字段。
+ * - 如果 manifest 不存在，根据配置完整生成。
+ * - dryRun 时返回结果但不写入文件。
+ * - 只修补已配置的 Pack（至少一个必须存在）。
+ */
+declare function patchManifest(options: PatchManifestOptions): Promise<Record<string, {
+  path: string;
+  updated: boolean;
+  existed: boolean;
+}>>;
+//#endregion
+//#region src/constants/dependencyCatalog.d.ts
+/** Built-in managed dependency catalog. Maps package names to resolver + manifest behavior. */
+declare const BUILTIN_DEPENDENCY_CATALOG: Record<string, DependencyCatalogEntry>;
+//#endregion
+//#region src/install/dependencyCatalog.d.ts
+declare function createDependencyCatalog(config: ResolvedConfig): Record<string, DependencyCatalogEntry>;
+//#endregion
+//#region src/install/MinecraftPackageResolver.d.ts
+declare function packageVersionForSpecifier(specifier: string): string;
+declare class MinecraftPackageResolver {
+  private readonly npm;
+  private readonly logger?;
+  constructor(npm: NpmRegistryClient, logger?: LoggerLike | undefined);
+  /** Resolve latest stable version from metadata, using dist-tag "latest" or falling back to highest stable. */
+  latestStable(packageName: string, metadata: NpmPackageMetadata): string;
+  /** Resolve latest beta version from metadata, using dist-tag "beta" or falling back to highest beta. */
+  latestBeta(packageName: string, metadata: NpmPackageMetadata): string;
+  /** Resolve the highest beta version matching a concrete Minecraft target (e.g. 1.21.120). */
+  betaForTarget(packageName: string, target: string, metadata: NpmPackageMetadata): string;
+  /** Infer the concurrent stable version from a beta version string. */
+  inferStableFromBeta(packageName: string, target: string, beta: string, metadata: NpmPackageMetadata): string;
+}
+//#endregion
+//#region src/install/DependencyService.d.ts
+type ResolvedDependency = {
+  specifier: string;
+  packageVersion: string;
+  manifestVersion: string | null;
+  manifest: boolean;
+  external: boolean;
+  resolver: string;
+};
+declare class DependencyService {
+  readonly config: ResolvedConfig;
+  readonly logger?: LoggerLike | undefined;
+  readonly npm: NpmRegistryClient;
+  readonly catalog: ReturnType<typeof createDependencyCatalog>;
+  readonly pkgResolver: MinecraftPackageResolver;
+  private readonly log;
+  constructor(config: ResolvedConfig, logger?: LoggerLike | undefined);
+  /**
+   * Resolve all managed dependencies from packs.bp.dependencies.
+   * Returns a map of package name to ResolvedDependency.
+   * Returns empty when BP is not configured or has no dependencies.
+   */
+  resolveAll(): Promise<Record<string, ResolvedDependency>>;
+  /**
+   * Resolve a single dependency to a concrete version.
+   */
+  resolveOne(packageName: string, specifier: DependencySpecifier, entry: DependencyCatalogEntry): Promise<{
+    packageVersion: string;
+    manifestVersion?: string | null;
+  }>;
+  private runDependencyHooks;
+}
+/** @deprecated Use `new DependencyService(config, logger).resolveAll()` instead. */
+declare function resolveDependencies(config: ResolvedConfig, logger?: LoggerLike): Promise<Record<string, ResolvedDependency>>;
+//#endregion
+//#region src/utils/semver.d.ts
+/**
+ * Checks Minecraft Script API compatibility, intentionally differing from
+ * standard npm semver. The actual version must have the same major and an API
+ * core version no lower than the requirement. When the requirement contains a
+ * Minecraft target inside a beta/preview suffix, the actual target must be no
+ * lower as well (for example, `1.26.33-beta` satisfies `1.26.30-beta`).
+ *
+ * `requirement` may have a common npm range prefix such as `^` or `>=`; the
+ * prefix is accepted for peer-dependency ergonomics but does not impose npm's
+ * usual upper bound.
+ */
+declare function satisfiesSemver(version: string, requirement: string): boolean;
+/** @deprecated Use satisfiesSemver; retained for plugins using the earlier name. */
+declare const satisfiesSemverRange: typeof satisfiesSemver;
+//#endregion
+//#region src/install/resolvers/registry.d.ts
+declare const BUILTIN_DEPENDENCY_RESOLVERS: DependencyResolverRule[];
+declare class DependencyResolverRegistry {
+  private readonly resolvers;
+  private readonly pluginNames;
+  constructor(resolvers: DependencyResolverRule[], plugins?: BePackPlugin[]);
+  static fromConfig(customResolvers: DependencyResolverRule[], plugins?: BePackPlugin[]): DependencyResolverRegistry;
+  private resolverMatchesCatalog;
+  find(ctx: DependencyResolverContext): DependencyResolverRule;
+  resolve(ctx: DependencyResolverContext): Promise<DependencyResolverResult>;
+}
+//#endregion
+//#region src/install/resolvers/minecraftScriptApi.d.ts
+declare const minecraftScriptApiResolver: DependencyResolverRule;
+//#endregion
+//#region src/install/resolvers/minecraftScriptApiBp.d.ts
+declare const minecraftScriptApiBpResolver: DependencyResolverRule;
+//#endregion
+//#region src/install/resolvers/minecraftVanillaData.d.ts
+declare const minecraftVanillaDataResolver: DependencyResolverRule;
+//#endregion
+//#region src/install/resolvers/exact.d.ts
+declare const exactVersionResolver: DependencyResolverRule;
+//#endregion
+//#region src/plugins/sapiPro.d.ts
+/**
+ * Resolves sapi-pro against explicitly declared Minecraft Script API packages.
+ * sapi-pro itself is package-only and is never written to manifest.json.
+ */
+declare function sapiPro(): BePackPlugin;
+//#endregion
+//#region src/plugins/builtins.d.ts
+/** Factories for plugins that can be referenced by name in project configs. */
+declare const BUILTIN_PLUGINS: Record<string, () => BePackPlugin>;
+//#endregion
+//#region src/errors/codes.d.ts
+declare const ERROR_CODES: readonly ["CONFIG_NOT_FOUND", "CONFIG_INVALID", "TARGET_INVALID", "TARGET_NOT_SUPPORTED", "UNSUPPORTED_DEPENDENCY", "DEPENDENCY_VERSION_INVALID", "DEPENDENCY_REQUIRES_INSTALL", "SAPI_VERSION_NOT_FOUND", "ACHIEVEMENT_REQUIRES_STABLE_API", "PACKAGE_JSON_NOT_FOUND", "PACKAGE_MANAGER_NOT_FOUND", "PACKAGE_MANAGER_FAILED", "MANIFEST_INVALID", "MANIFEST_GENERATE_FAILED", "MANIFEST_PATCH_FAILED", "VERSION_INVALID", "TYPECHECK_FAILED", "BUILD_FAILED", "COPY_TARGET_NOT_FOUND", "COPY_FAILED", "PACK_FAILED", "HOOK_FAILED", "PLUGIN_FAILED", "CLI_ARGUMENT_CONFLICT", "UNKNOWN_COMMAND"];
+type ErrorCode = (typeof ERROR_CODES)[number];
+//#endregion
+//#region src/errors/BePackError.d.ts
+declare class BePackError extends Error {
+  readonly code: ErrorCode;
+  readonly details: unknown | undefined;
+  readonly suggestions: string[] | undefined;
+  constructor(code: ErrorCode, message: string, options?: {
+    details?: unknown;
+    suggestions?: string[];
+  });
+}
+//#endregion
+export { BUILTIN_DEPENDENCY_CATALOG, BUILTIN_DEPENDENCY_RESOLVERS, BUILTIN_PLUGINS, BePackError, type BePackPlugin, type BpCompileOptions, type BpCompileResolved, type BpConfig, type ConfigResolvedHookContext, type DependencyCatalogEntry, type DependencyResolveHookContext, type DependencyResolvedHookContext, type DependencyResolverContext, DependencyResolverRegistry, type DependencyResolverResult, type DependencyResolverRule, DependencyService, type HookContext, MinecraftPackageResolver, type NpmPackageMetadata, type NpmPackageVersionMetadata, NpmRegistryClient, type PackInfo, type PackType, type PluginDependencyHooks, type ReplaceBuiltins, type ReplaceOptions, type ReplaceValue, type ResolvedConfig, type RpConfig, type UserConfig, createDependencyCatalog, defineConfig, exactVersionResolver, getConfiguredPacks, loadConfig, minecraftScriptApiBpResolver, minecraftScriptApiResolver, minecraftVanillaDataResolver, packageVersionForSpecifier, patchManifest, resolveDependencies, sapiPro, satisfiesSemver, satisfiesSemverRange };