@xylabs/toolchain 7.10.0

package/dist/index.d.ts

@@ -0,0 +1,1102 @@
+import { SpawnSyncOptionsWithBufferEncoding } from 'node:child_process';
+import { Options } from 'tsup';
+import { CompilerOptions } from 'typescript';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { PathLike, WriteFileOptions } from 'node:fs';
+import { PackageJson } from 'types-package-json';
+import { Argv } from 'yargs';
+
+declare const analyze: () => number;
+
+interface BuildParams {
+    incremental?: boolean;
+    jobs: number;
+    pkg?: string;
+    target?: 'esm' | 'cjs';
+    verbose?: boolean;
+}
+declare const build: ({ incremental, jobs, target, verbose, pkg, }: BuildParams) => Promise<number>;
+
+declare function claudeCheck(): number;
+
+declare function claudeClean(): number;
+
+declare const claudeCommands: () => number;
+
+declare const claudeRules: ({ force }?: {
+    force?: boolean;
+}) => number;
+
+type SettingsLevel = 'restrictive' | 'permissive';
+declare function claudeSettings({ level }?: {
+    level?: SettingsLevel;
+}): Promise<number>;
+
+declare const claudeSkills: () => number;
+
+interface CleanParams {
+    pkg?: string;
+    verbose?: boolean;
+}
+interface CleanPackageParams {
+    pkg: string;
+    verbose?: boolean;
+}
+declare const clean: ({ verbose, pkg }: CleanParams) => Promise<number>;
+declare const cleanPackage: ({ pkg }: CleanPackageParams) => Promise<number>;
+declare const cleanAll: ({ verbose }: CleanParams) => Promise<number>;
+
+declare const cleanDocs: () => number;
+
+declare const cleanESLint: () => number;
+
+interface CompileParams {
+    incremental?: boolean;
+    jobs: number;
+    pkg?: string;
+    publint?: boolean;
+    target?: 'esm' | 'cjs';
+    verbose?: boolean;
+}
+interface CompilePackageParams {
+    pkg: string;
+    publint?: boolean;
+    target?: 'esm' | 'cjs';
+    verbose?: boolean;
+}
+declare const compile: ({ verbose, target, pkg, incremental, publint, jobs, }: CompileParams) => number;
+declare const compilePackage: ({ target, pkg }: CompilePackageParams) => number;
+declare const compileAll: ({ jobs, verbose, target, incremental, }: CompileParams) => number;
+
+interface CopyAssetsParams {
+    pkg?: string;
+    target?: 'esm' | 'cjs';
+}
+declare const copyAssets: ({ target, pkg }: CopyAssetsParams) => Promise<0 | 1>;
+
+interface CycleParams {
+    incremental?: boolean;
+    jobs: number;
+    pkg?: string;
+    verbose?: boolean;
+}
+interface CyclePackageParams {
+    pkg: string;
+    verbose?: boolean;
+}
+declare const cycle: ({ verbose, pkg }: CycleParams) => Promise<number>;
+declare const cyclePackage: ({ pkg, verbose }: CyclePackageParams) => number;
+declare const cycleAll: ({ verbose }: {
+    verbose?: boolean;
+}) => Promise<number>;
+
+declare const dead: () => number;
+
+interface DepLintOptions {
+    /** Package names to exclude, passed via --exclude on the command line */
+    cliExclude?: string[];
+    deps?: boolean;
+    devDeps?: boolean;
+    fix?: boolean;
+    format?: 'human' | 'json';
+    peerDeps?: boolean;
+    pkg?: string;
+    verbose?: boolean;
+}
+declare const deplint: ({ pkg, deps, devDeps, fix, peerDeps, verbose, cliExclude, format, }: DepLintOptions) => Promise<0 | 1>;
+
+type PackageManagerName = 'pnpm' | 'yarn';
+declare function detectPackageManager(): PackageManagerName;
+
+declare function detectReact(): boolean;
+
+interface Workspace {
+    location: string;
+    name: string;
+}
+type ScriptStep = [/* command */ string, /* arg */ /* arg */ string | string[]] | [/* command */ string, /* arg */ /* arg */ string | string[], /* config */ SpawnSyncOptionsWithBufferEncoding];
+interface WorkspaceForeachOptions {
+    incremental?: boolean;
+    jobs: number;
+    topological?: boolean;
+    verbose?: boolean;
+}
+interface PackageManager {
+    /** The shell command to invoke this package manager (e.g., 'yarn', 'pnpm') */
+    command: string;
+    /** The lockfile name (e.g., 'yarn.lock', 'pnpm-lock.yaml') */
+    lockfile: string;
+    /** Package manager identifier */
+    name: 'pnpm' | 'yarn';
+    /** Remove duplicate dependencies */
+    dedupe(): ScriptStep;
+    /** Find a single workspace by name */
+    findWorkspace(name: string): Workspace | undefined;
+    /** Run a foreach command across all workspaces */
+    foreachWorkspace(script: string, args: string[], options: WorkspaceForeachOptions): ScriptStep;
+    /** Install dependencies */
+    install(): ScriptStep;
+    /** Returns a map of package name -> installed version for all dependencies across all workspaces */
+    listInstalledVersions(): Map<string, string>;
+    /** List all workspaces */
+    listWorkspaces(): Workspace[];
+    /** Show outdated dependencies */
+    outdated(): ScriptStep;
+    /** Publish all packages to the registry */
+    publish(): ScriptStep;
+    /** Run a script in a specific workspace */
+    runInWorkspace(pkg: string, script: string, args?: string[]): ScriptStep;
+    /** Run the xy CLI command */
+    runXy(args: string[]): ScriptStep;
+    /** Apply version changes */
+    versionApply(): ScriptStep;
+    /** Bump versions across workspaces */
+    versionBump(type: 'major' | 'minor' | 'patch' | 'prerelease'): ScriptStep[];
+}
+
+declare class PnpmPackageManager implements PackageManager {
+    readonly command = "pnpm";
+    readonly lockfile = "pnpm-lock.yaml";
+    readonly name: "pnpm";
+    dedupe(): ScriptStep;
+    findWorkspace(name: string): Workspace | undefined;
+    foreachWorkspace(script: string, args: string[] | undefined, options: WorkspaceForeachOptions): ScriptStep;
+    install(): ScriptStep;
+    listInstalledVersions(): Map<string, string>;
+    listWorkspaces(): Workspace[];
+    outdated(): ScriptStep;
+    publish(): ScriptStep;
+    runInWorkspace(pkg: string, script: string, args?: string[]): ScriptStep;
+    runXy(args: string[]): ScriptStep;
+    versionApply(): ScriptStep;
+    versionBump(type: 'major' | 'minor' | 'patch' | 'prerelease'): ScriptStep[];
+}
+
+declare function registerPackageManager(pm: PackageManager): void;
+declare function getPackageManager(name?: PackageManagerName): PackageManager;
+
+declare class YarnPackageManager implements PackageManager {
+    readonly command = "yarn";
+    readonly lockfile = "yarn.lock";
+    readonly name: "yarn";
+    dedupe(): ScriptStep;
+    findWorkspace(name: string): Workspace | undefined;
+    foreachWorkspace(script: string, args: string[] | undefined, options: WorkspaceForeachOptions): ScriptStep;
+    install(): ScriptStep;
+    listInstalledVersions(): Map<string, string>;
+    listWorkspaces(): Workspace[];
+    outdated(): ScriptStep;
+    publish(): ScriptStep;
+    runInWorkspace(pkg: string, script: string, args?: string[]): ScriptStep;
+    runXy(args: string[]): ScriptStep;
+    versionApply(): ScriptStep;
+    versionBump(type: 'major' | 'minor' | 'patch' | 'prerelease'): ScriptStep[];
+}
+
+interface CheckPackageParams {
+    dependencies: string[];
+    dependencyVersions: Record<string, string>;
+    devDependencies: string[];
+    devDependencyVersions: Record<string, string>;
+    peerDependencies: string[];
+    peerDependencyVersions: Record<string, string>;
+}
+interface CheckSourceParams {
+    allImportPaths: Record<string, string[]>;
+    allImports: string[];
+    distImportPaths: Record<string, string[]>;
+    distImports: string[];
+    externalAllImports: string[];
+    externalDistImports: string[];
+    externalDistTypeImports: string[];
+    tsconfigExtends: string[];
+}
+
+interface FileContext {
+    allFiles: string[];
+    distFiles: string[];
+}
+
+type DeplintSeverity = 'error' | 'warning';
+type DeplintSection = 'dependencies' | 'devDependencies' | 'peerDependencies';
+type DeplintFix = {
+    action: 'add';
+    dependency: string;
+    detail: string;
+    section: DeplintSection;
+    version: string;
+} | {
+    action: 'move';
+    dependency: string;
+    detail: string;
+    fromSection: DeplintSection;
+    toSection: DeplintSection;
+    version?: string;
+} | {
+    action: 'remove';
+    dependency: string;
+    detail: string;
+    section: DeplintSection;
+} | {
+    action: 'set-version';
+    dependency: string;
+    detail: string;
+    section: DeplintSection;
+    version: string;
+};
+interface DeplintDiagnostic {
+    dependency?: string;
+    evidence?: string[];
+    file: string;
+    fixes?: DeplintFix[];
+    id: string;
+    message: string;
+    severity: DeplintSeverity;
+    workspace: Workspace;
+}
+interface DeplintWorkspaceContext {
+    exclude?: Set<string>;
+    fileContext: FileContext;
+    /** Packages that must stay in `dependencies` (never promoted to peerDependencies). */
+    forceDeps: Set<string>;
+    /** Packages that must be in `peerDependencies` (moved from dependencies if needed). */
+    forcePeers: Set<string>;
+    isTerminalPackage: boolean;
+    packageJsonPath: string;
+    packageParams: CheckPackageParams;
+    sourceParams: CheckSourceParams;
+    unusedDependencyExclude: Set<string>;
+    workspace: Workspace;
+    workspaceNames?: Set<string>;
+}
+interface DeplintRule {
+    category: 'dependencies' | 'devDependencies' | 'peerDependencies';
+    evaluate: (context: DeplintWorkspaceContext) => DeplintDiagnostic[];
+    id: string;
+}
+interface DeplintRunOptions {
+    /** Package names passed via --exclude on the CLI (merged with config). */
+    cliExclude?: string[];
+    deps?: boolean;
+    devDeps?: boolean;
+    fix?: boolean;
+    peerDeps?: boolean;
+    pkg?: string;
+    reporter?: 'human' | 'json';
+    verbose?: boolean;
+}
+interface DeplintAppliedFix {
+    dependency: string;
+    detail: string;
+    workspace: Workspace;
+}
+interface DeplintSummary {
+    appliedFixes: number;
+    errorCount: number;
+    warningCount: number;
+    workspacesChecked: number;
+}
+interface DeplintRunResult {
+    appliedFixes: DeplintAppliedFix[];
+    diagnostics: DeplintDiagnostic[];
+    summary: DeplintSummary;
+}
+interface DeplintReporter {
+    render: (result: DeplintRunResult) => void;
+}
+
+declare function runDeplint(workspaces: Workspace[], options: DeplintRunOptions, workspaceNames?: Set<string>): Promise<DeplintRunResult>;
+
+declare function applyDeplintFixes(diagnostics: DeplintDiagnostic[]): DeplintAppliedFix[];
+
+declare class DeplintPackageEditor {
+    private readonly workspace;
+    private readonly pkg;
+    constructor(workspace: Workspace);
+    applyFix(fix: DeplintFix): DeplintAppliedFix;
+    save(): void;
+}
+
+declare const humanDeplintReporter: DeplintReporter;
+declare const jsonDeplintReporter: DeplintReporter;
+declare function getDeplintReporter(format: 'human' | 'json'): DeplintReporter;
+
+declare const deplintRules: DeplintRule[];
+
+declare function buildWorkspaceContext(workspace: Workspace, exclude?: Set<string>, workspaceNames?: Set<string>, forceDeps?: Set<string>, forcePeers?: Set<string>): DeplintWorkspaceContext;
+
+type DeployLevel = 'major' | 'minor' | 'patch' | 'prerelease';
+declare function deploy(level?: DeployLevel): number;
+
+declare const dupdeps: () => number;
+
+declare const eject: () => number;
+
+interface LintParams {
+    cache?: boolean;
+    fix?: boolean;
+    incremental?: boolean;
+    jobs: number;
+    next?: boolean;
+    pkg?: string;
+    verbose?: boolean;
+}
+interface LintPackageParams {
+    pkg: string;
+    verbose?: boolean;
+}
+declare const lintPackage: ({ pkg, fix, verbose, }: {
+    fix?: boolean;
+    pkg: string;
+    verbose?: boolean;
+}) => number;
+declare const lint: ({ cache, fix, jobs, next, pkg, verbose, }: LintParams) => number | Promise<number>;
+declare const lintAllPackages: ({ fix }?: {
+    fix?: boolean;
+}) => number;
+
+declare const fix: (params: LintParams) => number | Promise<number>;
+
+interface GenDocsParams {
+    incremental?: boolean;
+    jobs: number;
+    pkg?: string;
+}
+interface GenDocsPackageParams {
+    pkg: string;
+}
+declare const genDocs: ({ jobs, pkg, incremental, }: GenDocsParams) => number;
+declare const genDocsPackage: ({ pkg }: GenDocsPackageParams) => number;
+declare const genDocsAll: ({ incremental, jobs }: GenDocsParams) => number;
+
+/** @deprecated Use gitignore instead */
+declare const gitignoreGen: typeof gitignore;
+declare function gitignore(): number;
+
+declare const gitlint: () => 0 | 1;
+
+declare const gitlintFix: () => number;
+
+declare const knip: () => number;
+
+declare const license: (pkg?: string) => Promise<number>;
+
+interface LintInitParams {
+    verbose?: boolean;
+}
+declare function detectReactInMonorepo(cwd: string, verbose?: boolean): boolean;
+declare function lintInit({ verbose }?: LintInitParams): Promise<number>;
+
+interface LintlintParams {
+    fix?: boolean;
+    verbose?: boolean;
+}
+declare function lintlint({ fix, verbose }?: LintlintParams): Promise<number>;
+
+interface LintNextParams {
+    cache?: boolean;
+    fix?: boolean;
+    jobs: number;
+    pkg?: string;
+    verbose?: boolean;
+}
+declare function lintNext({ cache, fix, jobs, pkg, verbose, }: LintNextParams): Promise<number>;
+
+declare const npmignoreGen: (pkg?: string) => 0 | 1;
+
+interface OrphanParams {
+    verbose?: boolean;
+}
+declare function orphanList({ verbose }?: OrphanParams): number;
+declare function orphanClean({ verbose }?: OrphanParams): number;
+
+declare const packageClean: () => number;
+
+declare const packageCleanOutputs: () => number;
+
+declare const packageCleanTypescript: () => number;
+
+type EntryMode = 'all' | 'single' | 'auto' | 'platform' | 'custom';
+/**
+ * Configuration for specifying which paths are targeted.
+ */
+interface PathConfig {
+    /**
+     * Glob patterns to exclude (takes precedence over include).
+     */
+    exclude?: string[];
+    /**
+     * Glob patterns to include.
+     */
+    include?: string[];
+}
+/**
+ * Configuration for Dynamic Share.
+ */
+interface DynamicShareConfig extends PathConfig {
+}
+/**
+ * Configuration for Live Share.
+ */
+interface LiveShareConfig extends PathConfig {
+}
+interface CompileConfig {
+    bundleTypes?: boolean;
+    /** @param entryMode all, single, custom, platform, or auto */
+    entryMode?: EntryMode;
+    /** @param when building types with tsc, should it use the outDir to write to? */
+    outDirAsBuildDir?: boolean;
+}
+type PackageCompileTsupConfig = CompileConfig & {
+    browser?: Record<string, Options | boolean>;
+    neutral?: Record<string, Options | boolean>;
+    node?: Record<string, Options | boolean>;
+    tsup?: {
+        options?: Options;
+    };
+    verbose?: boolean;
+};
+type PackageCompileTscConfig = CompileConfig & {
+    mode: 'tsc';
+};
+/**
+ * How deplint should classify a dependency.
+ * - `dep`: must stay in `dependencies` (never promoted to peerDependencies)
+ * - `peer`: should be treated as a peerDependency (overrides a parent `dep` setting)
+ */
+type DeplintRefType = 'dep' | 'peer';
+/**
+ * Per-package configuration within deplint.
+ */
+interface DeplintPackageConfig {
+    /** How this dependency should be classified. */
+    refType: DeplintRefType;
+}
+/**
+ * Configuration for deplint (dependency linting).
+ */
+interface DeplintConfig {
+    /**
+     * Package names to exclude from unused-dependency checks.
+     * Packages listed here will never be reported as "unused" by deplint,
+     * even if no import for them is detected in source or dist files.
+     * Useful for packages that are used implicitly (e.g. runtime plugins,
+     * CSS-in-JS themes, or polyfills that have side effects on import).
+     */
+    exclude?: string[];
+    /**
+     * Per-dependency configuration keyed by package name.
+     * Cascades from root to package configs (maps are merged, with
+     * package-level entries overriding root-level entries for the same key).
+     */
+    packages?: Record<string, DeplintPackageConfig>;
+}
+/**
+ * Canonical names for individually toggleable publint checks.
+ */
+type PublintCheckName = 'files' | 'importToDefault' | 'main' | 'module' | 'peerDeps' | 'publint' | 'resolutions' | 'rootSource' | 'rootTypes' | 'sideEffects' | 'source' | 'types';
+declare const ALL_PUBLINT_CHECKS: PublintCheckName[];
+/** Checks that only apply to published (non-private) packages */
+declare const PUBLISH_ONLY_CHECKS: PublintCheckName[];
+/**
+ * Configuration for publint (package publishing linting).
+ */
+interface PublintConfig {
+    /**
+     * Check names to exclude from publint runs.
+     * All checks run by default; listed names are skipped.
+     * Cannot be used together with `include`.
+     */
+    exclude?: PublintCheckName[];
+    /**
+     * Check names to include (whitelist) in publint runs.
+     * Only listed checks will run; all others are skipped.
+     * Cannot be used together with `exclude`.
+     */
+    include?: PublintCheckName[];
+    /**
+     * Whether to run `pack` when invoking the publint library.
+     * When true (default), the package manager is used to determine which
+     * files would be published. Set to false to skip packing for faster runs.
+     */
+    pack?: boolean;
+}
+/**
+ * Configuration for readme generation.
+ */
+interface ReadmeConfig {
+    /**
+     * URL that the logo links to when clicked.
+     * Replaces the placeholder in the template's [![logo][]](url) link.
+     */
+    logoLinkUrl?: string;
+    /**
+     * Public URL for the logo image displayed at the top of generated READMEs.
+     * Replaces the placeholder in the template's [logo] reference link.
+     */
+    logoUrl?: string;
+}
+/**
+ * Command-specific configuration that cascades from root to package.
+ * Settings here override the legacy top-level equivalents.
+ */
+interface CommandsConfig {
+    deplint?: DeplintConfig;
+    publint?: boolean | PublintConfig;
+}
+interface XyConfigBase {
+    /**
+     * Command-specific settings grouped under `commands`.
+     * These cascade from root xy.config down to per-package xy.config files.
+     * Takes precedence over the legacy top-level `deplint`/`publint` fields.
+     */
+    commands?: CommandsConfig;
+    compile?: CompileConfig;
+    /** @deprecated Use `commands.deplint` instead. */
+    deplint?: DeplintConfig;
+    dynamicShare?: DynamicShareConfig;
+    liveShare?: LiveShareConfig;
+    /** @deprecated Use `commands.publint` instead. */
+    publint?: boolean | PublintConfig;
+    readme?: ReadmeConfig;
+    verbose?: boolean;
+}
+interface XyTsupConfig extends XyConfigBase {
+    compile?: PackageCompileTsupConfig;
+}
+interface XyTscConfig extends XyConfigBase {
+    compile?: PackageCompileTscConfig;
+}
+type XyConfigLegacy = XyTsupConfig | XyTscConfig;
+type XyConfig = XyConfigLegacy & {
+    dev?: {
+        build?: {
+            clean?: boolean;
+            compile?: boolean;
+            deplint?: boolean;
+            gendocs?: boolean;
+            gitlint?: boolean;
+            knip?: boolean;
+            license?: boolean;
+            lint?: boolean;
+            publint?: boolean;
+            statics?: boolean;
+            verbose?: boolean;
+        };
+        compile?: PackageCompileTsupConfig;
+        verbose?: boolean;
+    };
+    verbose?: boolean;
+};
+
+declare const packageCompile: (inConfig?: XyConfig) => Promise<number>;
+
+declare const packageCompileTsc: (platform: "browser" | "neutral" | "node", entries: string[], srcDir?: string, outDir?: string, compilerOptionsParam?: CompilerOptions, verbose?: boolean) => number;
+
+declare const tsupOptions: (options?: Options[]) => Options;
+declare const packageCompileTsup: (config?: XyTsupConfig) => Promise<number>;
+
+interface PackageCopyAssetsParams {
+    target?: 'esm' | 'cjs';
+}
+declare const packageCopyAssets: ({ target }: PackageCopyAssetsParams) => Promise<0 | 1>;
+
+declare const packageCycle: () => Promise<number>;
+
+declare const packageGenDocs: () => Promise<number | undefined>;
+
+declare const packageLint: (fix?: boolean, verbose?: boolean, cache?: boolean) => Promise<number>;
+
+interface PackagePublintParams {
+    exclude?: Set<PublintCheckName>;
+    fix?: boolean;
+    pack?: boolean;
+    pkgDir?: string;
+    strict?: boolean;
+    verbose?: boolean;
+}
+declare const packagePublint: ({ exclude, fix, pack, pkgDir: pkgDirParam, strict, verbose: _verbose, }?: PackagePublintParams) => Promise<number>;
+
+declare const packageRecompile: () => Promise<number>;
+
+interface LintResult {
+    errors: string[];
+    fixable: string[];
+    warnings: string[];
+}
+declare function packageLintMonorepo(fix?: boolean): number;
+
+declare function checkVersionConsistency(cwd: string, rootPkg: Record<string, unknown>, workspaces: {
+    location: string;
+    name: string;
+}[]): LintResult;
+declare function fixVersionConsistency(cwd: string, rootPkg: Record<string, unknown>, writeRootPackageJson: (cwd: string, pkg: Record<string, unknown>) => void, workspaces: {
+    location: string;
+    name: string;
+}[]): void;
+declare function checkInternalDepVersions(cwd: string, workspaces: {
+    location: string;
+    name: string;
+}[]): LintResult;
+declare function fixInternalDepVersions(cwd: string, workspaces: {
+    location: string;
+    name: string;
+}[]): void;
+declare function checkWorkspaceProtocol(cwd: string, workspaces: {
+    location: string;
+    name: string;
+}[]): LintResult;
+declare function fixWorkspaceProtocol(cwd: string, workspaces: {
+    location: string;
+    name: string;
+}[]): void;
+declare function checkInternalPeerVersions(cwd: string, workspaces: {
+    location: string;
+    name: string;
+}[]): LintResult;
+declare function fixInternalPeerVersions(cwd: string, workspaces: {
+    location: string;
+    name: string;
+}[]): void;
+/**
+ * Syncs all internal peerDependency versions to match current workspace versions.
+ * Called by xy publish to ensure peerDeps are correct before publishing.
+ */
+declare function syncInternalPeerVersions(): number;
+/**
+ * Reads the shared monorepo version from the first non-root workspace
+ * and logs it. Call at the end of deploy to report the new version.
+ */
+declare function logMonorepoVersion(): void;
+
+interface PackmanCleanParams {
+    verbose?: boolean;
+}
+declare function packmanClean({ verbose }: PackmanCleanParams): number;
+
+interface ConvertParams {
+    target: string;
+    verbose?: boolean;
+}
+declare function detectCurrentPM(cwd: string): 'pnpm' | 'yarn' | 'unknown';
+declare function findWorkspacePackagePaths(cwd: string): string[];
+declare function convert({ target, verbose }: ConvertParams): number;
+
+interface PackmanLintParams {
+    fix?: boolean;
+    verbose?: boolean;
+}
+declare function packmanLint({ fix, verbose }?: PackmanLintParams): number;
+
+type Direction = 'pnpm-to-yarn' | 'yarn-to-pnpm';
+declare function rewriteScript(script: string, direction: Direction): string;
+declare function rewriteScriptsInPackageJson(pkg: Record<string, unknown>, direction: Direction): Record<string, unknown>;
+
+interface PublintParams {
+    cliExclude?: string[];
+    cliInclude?: string[];
+    fix?: boolean;
+    jobs: number;
+    pack?: boolean;
+    pkg?: string;
+    verbose?: boolean;
+}
+interface PublintPackageParams {
+    exclude: Set<PublintCheckName>;
+    fix?: boolean;
+    pack?: boolean;
+    pkg: string;
+    verbose?: boolean;
+}
+interface ResolvedPublintOptions {
+    exclude: Set<PublintCheckName>;
+    pack: boolean;
+}
+declare function loadPublintOptions(): Promise<ResolvedPublintOptions>;
+declare const publint: ({ cliExclude, cliInclude, fix, jobs, pack, verbose, pkg, }: PublintParams) => Promise<number>;
+interface PublintSingleParams {
+    cliExclude?: string[];
+    cliInclude?: string[];
+    fix?: boolean;
+    pack?: boolean;
+    pkg: string;
+    verbose?: boolean;
+}
+declare const publintSingle: ({ cliExclude, cliInclude, fix, pack, pkg, verbose, }: PublintSingleParams) => Promise<number>;
+interface PublintAllParams {
+    cliExclude?: string[];
+    cliInclude?: string[];
+    fix?: boolean;
+    jobs: number;
+    pack?: boolean;
+    verbose?: boolean;
+}
+declare const publintAll: ({ cliExclude, cliInclude, fix, jobs, pack, verbose, }: PublintAllParams) => Promise<number>;
+
+declare const publish: () => number;
+
+declare const test$1: () => number;
+
+interface ReadmeGenParams {
+    jobs: number;
+    pkg?: string;
+    templatePath?: string;
+    typedoc?: boolean;
+    verbose?: boolean;
+}
+declare function readmeGen({ jobs, pkg, templatePath, typedoc, verbose, }: ReadmeGenParams): Promise<number>;
+
+interface ReadmeInitParams {
+    templatePath?: string;
+    verbose?: boolean;
+}
+declare function readmeInit({ templatePath }: ReadmeInitParams): Promise<number>;
+
+interface ReadmeLintParams {
+    config: XyConfig;
+    verbose?: boolean;
+}
+declare function readmeLint({ config, verbose }: ReadmeLintParams): number;
+
+interface RebuildParams {
+    pkg?: string;
+    target?: 'esm' | 'cjs';
+}
+declare const rebuild: ({ target }: RebuildParams) => number;
+
+interface RecompileParams {
+    incremental?: boolean;
+    jobs: number;
+    pkg?: string;
+    target?: 'esm' | 'cjs';
+    verbose?: boolean;
+}
+interface RecompilePackageParams {
+    pkg: string;
+    target?: 'esm' | 'cjs';
+    verbose?: boolean;
+}
+declare const recompile: ({ incremental, jobs, pkg, target, verbose, }: RecompileParams) => Promise<number>;
+declare const recompilePackage: ({ target, pkg }: RecompilePackageParams) => Promise<number>;
+declare const recompileAll: ({ jobs, verbose, target, incremental, }: RecompileParams) => Promise<number>;
+
+declare const reinstall: (verbose?: boolean) => number;
+
+interface RelintParams {
+    cache?: boolean;
+    fix?: boolean;
+    incremental?: boolean;
+    jobs: number;
+    next?: boolean;
+    pkg?: string;
+    verbose?: boolean;
+}
+interface RelintPackageParams {
+    pkg: string;
+    verbose?: boolean;
+}
+declare const relintPackage: ({ pkg, fix, verbose, }: {
+    fix?: boolean;
+    pkg: string;
+    verbose?: boolean;
+}) => number;
+declare const relint: ({ fix, jobs, next, pkg, verbose, }: RelintParams) => number | Promise<number>;
+declare const relintAllPackages: ({ fix }?: {
+    fix?: boolean;
+}) => number;
+
+interface RepoInitParams {
+    description: string;
+    githubOrg?: string;
+    name?: string;
+    packageName?: string;
+    pm: 'pnpm' | 'yarn';
+    scope: string;
+    skipGit?: boolean;
+    skipInstall?: boolean;
+    template: string;
+    verbose?: boolean;
+}
+declare function repoInit(params: RepoInitParams): Promise<number>;
+
+interface RetestParams {
+    target?: string;
+}
+declare const retest: ({ target }?: RetestParams) => number;
+
+declare const sitemap: () => number;
+
+declare const sonar: () => number;
+
+declare const start: () => number;
+
+declare const statics: () => number;
+
+interface TestParams {
+    target?: string;
+}
+declare const test: ({ target }?: TestParams) => number;
+
+declare const up: () => number;
+
+declare const updo: ({ latest }?: {
+    latest?: boolean;
+}) => Promise<number>;
+
+declare const updateYarnPlugins: () => number;
+
+declare const updateYarnVersion: () => number;
+
+declare const yarn3Only: () => number;
+
+declare const checkResult: (name: string, result: number, level?: "error" | "warn", exitOnFail?: boolean) => void;
+
+declare function applyPackageManager(content: string, pm: PackageManagerName): string;
+declare const XYLABS_RULES_PREFIX = "xylabs-";
+declare const XYLABS_COMMANDS_PREFIX = "xy-";
+declare const LEGACY_COMMANDS_PREFIX = "xylabs-";
+declare const XYLABS_SKILLS_PREFIX = "xylabs-";
+declare const claudeMdRuleTemplates: () => Record<string, string>;
+declare const claudeCommandTemplates: () => Record<string, string>;
+declare const claudeSkillTemplates: () => Record<string, Record<string, string>>;
+declare const claudeMdProjectTemplate: () => string;
+declare const claudeMdLocalTemplate: () => string;
+
+declare const outputStorage: AsyncLocalStorage<string[]>;
+declare function installOutputCapture(): void;
+declare function runWithConcurrency<T>(items: T[], concurrency: number, fn: (item: T) => Promise<void>): Promise<void>;
+
+declare const createBuildConfig: (location: string, module: "ESNext" | "CommonJS", target: "ESNext" | "ES6", outDirSuffix: string) => Record<string, unknown> | undefined;
+
+declare const defaultBuildConfig: {
+    compilerOptions: {
+        rootDir: string;
+        rootDirs: string[];
+    };
+    exclude: string[];
+    include: string[];
+};
+
+declare const deleteGlob: (globPath: string) => void;
+
+declare const detectDuplicateDependencies: (depsFromPackageJSON?: string[], DefaultDependencies?: string[]) => number;
+
+declare class DuplicateDetector {
+    private dependency;
+    private duplicateVersions;
+    constructor(output: string, dependency: string);
+    detect(): number;
+    private parseVersions;
+}
+
+interface CycleEdge {
+    from: string;
+    to: string;
+    type: 'dep' | 'devDep';
+}
+/**
+ * Detects cycles in the workspace dependency graph (including devDependencies).
+ * This catches cycles that break `yarn workspaces foreach --topological-dev`
+ * but are invisible to source-level import analysis.
+ * @returns An array of cycle paths, each represented as an array of edges. Empty if no cycles.
+ */
+declare function detectWorkspaceCycles(workspaces: Workspace[]): CycleEdge[][];
+declare function printWorkspaceCycles(cycles: CycleEdge[][]): void;
+
+declare const WINDOWS_NEWLINE_REGEX: RegExp;
+declare const CROSS_PLATFORM_NEWLINE = "\n";
+
+type ReadFileSyncOptions = BufferEncoding | {
+    encoding: BufferEncoding;
+    flags?: string;
+};
+declare const defaultReadFileSyncOptions: ReadFileSyncOptions;
+
+declare const readLines: (uri: PathLike, options?: ReadFileSyncOptions) => string[];
+declare const readNonEmptyLines: (uri: PathLike, options?: ReadFileSyncOptions) => string[];
+declare const writeLines: (uri: PathLike, lines: string[], options?: WriteFileOptions) => void;
+
+declare const tryReadFileSync: (uri: PathLike, options?: ReadFileSyncOptions) => string | undefined;
+
+declare function fillTemplate(template: string, data: Record<string, string>): string;
+
+declare const generateIgnoreFiles: (filename: string, pkg?: string) => 0 | 1;
+
+interface GenerateReadmeFilesParams {
+    jobs: number;
+    logoLinkUrl?: string;
+    logoUrl?: string;
+    pkg?: string;
+    templatePath?: string;
+    typedoc?: boolean;
+    verbose?: boolean;
+}
+declare const DEFAULT_README_TEMPLATE: string;
+declare const DEFAULT_README_BODY: string;
+declare function applyLogoConfig(template: string, logoUrl?: string, logoLinkUrl?: string): string;
+declare function resolveTemplatePath(templatePath?: string): string;
+declare function scaffoldTemplate(resolvedTemplatePath: string, template: string): Promise<void>;
+declare function generateReadmeFiles({ jobs, logoLinkUrl, logoUrl, pkg, templatePath, typedoc, verbose, }: GenerateReadmeFilesParams): Promise<number>;
+
+declare const gitignoreTemplate: () => string;
+
+declare function INIT_CWD(): string;
+
+declare const multiLineToJSONArray: (output: string) => unknown[];
+
+declare const latestVersions: {
+    readonly node: "24.14.1";
+    readonly nodeLtsCodename: "Krypton";
+    readonly npm: "11.11.0";
+    readonly pnpm: "10.33.0";
+    readonly yarn: "4.13.0";
+};
+
+declare const loadConfig: <T extends object>(params?: T) => Promise<T>;
+/**
+ * Loads a command-specific config merged from root and workspace levels.
+ * The root config provides defaults; the workspace config extends/overrides.
+ * Arrays (e.g. `exclude`) are unioned and maps (e.g. `packages`) are merged
+ * via deepmerge, with workspace entries overriding root entries for the same key.
+ */
+declare function loadWorkspaceCommandConfig<C>(workspaceDir: string, commandName: string): Promise<C>;
+
+declare function packageName(): string | undefined;
+
+declare const parsedPackageJSON: (path?: string) => Record<string, unknown>;
+
+declare const processEx: (ex: unknown) => never;
+
+interface TemplateFile {
+    content: string;
+    relativePath: string;
+}
+declare function loadRepoTemplateFiles(template: string, section: string): TemplateFile[];
+declare function listRepoTemplates(): string[];
+
+declare function runInstall(cwd?: string): boolean;
+
+declare const runSteps: (name: string, steps: ScriptStep[], exitOnFail?: boolean, messages?: string[]) => number;
+
+declare const runStepAsync: (name: string, step: ScriptStep, exitOnFail?: boolean, message?: string) => Promise<number>;
+declare const runStepsAsync: (name: string, steps: ScriptStep[], exitOnFail?: boolean, messages?: string[]) => Promise<number>;
+
+declare const runXy: (command: string) => number;
+
+declare const runXyWithWarning: (command: string) => number;
+
+/** Catch child process a crash and returns the code */
+declare const safeExit: (func: () => number, exitOnFail?: boolean) => number;
+declare const safeExitAsync: (func: () => Promise<number>, exitOnFail?: boolean) => Promise<number>;
+
+declare const empty: (value?: string) => boolean;
+declare const notEmpty: (value?: string) => boolean;
+
+declare const union: (a: string[], b: string[]) => Set<string>;
+
+/**
+ * Attempts to run a local root package.json script instead of the built-in
+ * xy command. Returns the exit code if the override ran, or undefined if
+ * no override applies (no matching script or recursion guard).
+ */
+declare function tryRunLocalScript(commandName: string): number | undefined;
+
+type DepType = 'dependencies' | 'devDependencies' | 'peerDependencies';
+interface DeclaredDep {
+    depTypes: DepType[];
+    name: string;
+    ranges: string[];
+    workspaces: string[];
+}
+interface RegistryInfo {
+    distTags: Record<string, string>;
+    versions: string[];
+}
+interface ResolvedDep {
+    current: string | undefined;
+    declaredRange: string;
+    depTypes: DepType[];
+    latest: string | undefined;
+    name: string;
+    next: string | undefined;
+    updateAvailable: boolean;
+    wanted: string | undefined;
+    workspaces: string[];
+}
+type VersionChoice = 'latest' | 'next' | 'skip' | 'wanted';
+interface SelectedUpdate {
+    depTypes: DepType[];
+    name: string;
+    targetVersion: string;
+    workspaces: string[];
+}
+
+declare function applyUpdates(cwd: string, workspaces: Workspace[], updates: SelectedUpdate[]): number;
+
+declare function collectWorkspaceDeps(cwd: string, workspaces: Workspace[], workspaceNames: Set<string>): Map<string, DeclaredDep>;
+
+declare function fetchRegistryInfo(packageName: string): Promise<RegistryInfo>;
+declare function fetchAllRegistryInfo(packageNames: string[], concurrency?: number): Promise<Map<string, RegistryInfo>>;
+
+declare function interactiveSelect(deps: ResolvedDep[]): Promise<SelectedUpdate[]>;
+
+declare function renderTable(deps: ResolvedDep[]): void;
+
+declare function resolveVersions(deps: Map<string, DeclaredDep>, registry: Map<string, RegistryInfo>, installedVersions: Map<string, string>): ResolvedDep[];
+
+interface UpdoOptions {
+    latest?: boolean;
+}
+declare function runUpdo(pm: PackageManager, _options?: UpdoOptions): Promise<number>;
+
+declare const withErrnoException: <T extends NodeJS.ErrnoException = NodeJS.ErrnoException>(ex: unknown, closure: (error: T) => number) => number | undefined;
+
+declare const withError: <T extends Error = Error>(ex: any, closure: (error: T) => number, predicate?: (ex: T) => boolean) => number | undefined;
+
+declare const isYarnVersionOrGreater: (major: number, minor?: number, patch?: number) => [boolean, string];
+
+declare const yarnWorkspace: (pkg: string) => Workspace;
+
+declare const yarnWorkspaces: () => Workspace[];
+
+type PackageJsonEx = PackageJson & {
+    type: 'module' | 'commonjs';
+};
+declare const loadPackageConfig: () => Promise<PackageJsonEx>;
+
+declare const xyBuildCommands: (args: Argv) => Argv<{}>;
+
+declare const xyCommonCommands: (args: Argv) => Argv<{}>;
+
+declare const xyDeployCommands: (args: Argv) => Argv<{}>;
+
+declare const xyInstallCommands: (args: Argv) => Argv<{}>;
+
+declare const xyLintCommands: (args: Argv) => Argv<{}>;
+
+declare const xyReactCommands: (args: Argv) => Argv<{}>;
+
+declare const xyBase: (plugins?: (args: Argv) => Argv) => Promise<{
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+} | {
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+}>;
+declare const xy: () => Promise<{
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+} | {
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+}>;
+
+declare const xyParseOptions: () => Argv;
+
+declare const xyYarnCommands: (args: Argv) => Argv<{}>;
+
+export { ALL_PUBLINT_CHECKS, type BuildParams, CROSS_PLATFORM_NEWLINE, type CleanPackageParams, type CleanParams, type CommandsConfig, type CompileConfig, type CompileParams, type ConvertParams, type CopyAssetsParams, type CycleEdge, type CycleParams, DEFAULT_README_BODY, DEFAULT_README_TEMPLATE, type DeclaredDep, type DepLintOptions, type DepType, type DeplintAppliedFix, type DeplintConfig, type DeplintDiagnostic, type DeplintFix, type DeplintPackageConfig, DeplintPackageEditor, type DeplintRefType, type DeplintReporter, type DeplintRule, type DeplintRunOptions, type DeplintRunResult, type DeplintSection, type DeplintSeverity, type DeplintSummary, type DeplintWorkspaceContext, type DeployLevel, DuplicateDetector, type DynamicShareConfig, type EntryMode, type GenDocsPackageParams, type GenDocsParams, INIT_CWD, LEGACY_COMMANDS_PREFIX, type LintInitParams, type LintNextParams, type LintPackageParams, type LintParams, type LintResult, type LiveShareConfig, type OrphanParams, PUBLISH_ONLY_CHECKS, type PackageCompileTscConfig, type PackageCompileTsupConfig, type PackageCopyAssetsParams, type PackageJsonEx, type PackageManager, type PackageManagerName, type PackagePublintParams, type PackmanCleanParams, type PackmanLintParams, type PathConfig, PnpmPackageManager, type PublintCheckName, type PublintConfig, type PublintPackageParams, type PublintParams, type ReadFileSyncOptions, type ReadmeConfig, type ReadmeGenParams, type ReadmeInitParams, type ReadmeLintParams, type RebuildParams, type RecompilePackageParams, type RecompileParams, type RegistryInfo, type RelintPackageParams, type RelintParams, type RepoInitParams, type ResolvedDep, type ResolvedPublintOptions, type RetestParams, type ScriptStep, type SelectedUpdate, type SettingsLevel, type TemplateFile, type TestParams, type UpdoOptions, type VersionChoice, WINDOWS_NEWLINE_REGEX, type Workspace, type WorkspaceForeachOptions, XYLABS_COMMANDS_PREFIX, XYLABS_RULES_PREFIX, XYLABS_SKILLS_PREFIX, type XyConfig, type XyConfigBase, type XyConfigLegacy, type XyTscConfig, type XyTsupConfig, YarnPackageManager, analyze, applyDeplintFixes, applyLogoConfig, applyPackageManager, applyUpdates, build, buildWorkspaceContext, checkInternalDepVersions, checkInternalPeerVersions, checkResult, checkVersionConsistency, checkWorkspaceProtocol, claudeCheck, claudeClean, claudeCommandTemplates, claudeCommands, claudeMdLocalTemplate, claudeMdProjectTemplate, claudeMdRuleTemplates, claudeRules, claudeSettings, claudeSkillTemplates, claudeSkills, clean, cleanAll, cleanDocs, cleanESLint, cleanPackage, collectWorkspaceDeps, compile, compileAll, compilePackage, convert, copyAssets, createBuildConfig, cycle, cycleAll, cyclePackage, dead, defaultBuildConfig, defaultReadFileSyncOptions, deleteGlob, deplint, deplintRules, deploy, detectCurrentPM, detectDuplicateDependencies, detectPackageManager, detectReact, detectReactInMonorepo, detectWorkspaceCycles, dupdeps, eject, empty, fetchAllRegistryInfo, fetchRegistryInfo, fillTemplate, findWorkspacePackagePaths, fix, fixInternalDepVersions, fixInternalPeerVersions, fixVersionConsistency, fixWorkspaceProtocol, genDocs, genDocsAll, genDocsPackage, generateIgnoreFiles, generateReadmeFiles, getDeplintReporter, getPackageManager, gitignore, gitignoreGen, gitignoreTemplate, gitlint, gitlintFix, humanDeplintReporter, installOutputCapture, interactiveSelect, isYarnVersionOrGreater, jsonDeplintReporter, knip, latestVersions, license, lint, lintAllPackages, lintInit, lintNext, lintPackage, lintlint, listRepoTemplates, loadConfig, loadPackageConfig, loadPublintOptions, loadRepoTemplateFiles, loadWorkspaceCommandConfig, logMonorepoVersion, multiLineToJSONArray, notEmpty, npmignoreGen, orphanClean, orphanList, outputStorage, packageClean, packageCleanOutputs, packageCleanTypescript, packageCompile, packageCompileTsc, packageCompileTsup, packageCopyAssets, packageCycle, packageGenDocs, packageLint, packageLintMonorepo, packageName, packagePublint, packageRecompile, packmanClean, packmanLint, parsedPackageJSON, printWorkspaceCycles, processEx, publint, publintAll, publintSingle, publish, test$1 as reactTest, readLines, readNonEmptyLines, readmeGen, readmeInit, readmeLint, rebuild, recompile, recompileAll, recompilePackage, registerPackageManager, reinstall, relint, relintAllPackages, relintPackage, renderTable, repoInit, resolveTemplatePath, resolveVersions, retest, rewriteScript, rewriteScriptsInPackageJson, runDeplint, runInstall, runStepAsync, runSteps, runStepsAsync, runUpdo, runWithConcurrency, runXy, runXyWithWarning, safeExit, safeExitAsync, scaffoldTemplate, sitemap, sonar, start, statics, syncInternalPeerVersions, test, tryReadFileSync, tryRunLocalScript, tsupOptions, union, up, updateYarnPlugins, updateYarnVersion, updo, withErrnoException, withError, writeLines, xy, xyBase, xyBuildCommands, xyCommonCommands, xyDeployCommands, xyInstallCommands, xyLintCommands, xyParseOptions, xyReactCommands, xyYarnCommands, yarn3Only, yarnWorkspace, yarnWorkspaces };