import { SpawnSyncOptionsWithBufferEncoding, SpawnSyncOptionsWithStringEncoding, SpawnSyncReturns } 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>;

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<1 | 0>;

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 PublishOptions {
    /**
     * Max workspaces per pnpm publish invocation. Each chunk spawns a fresh
     * pnpm process, which tears down and rebuilds Node's heap — a hard upper
     * bound on long-sequence OOM. `0` or `undefined` disables chunking (single
     * `pnpm publish -r` call) — this is the default.
     *
     * IMPORTANT: if the npm account requires interactive 2FA / web-login per
     * publish (the default npmjs behavior outside of GitHub Actions Trusted
     * Publishing), each chunk triggers a fresh auth ceremony. Chunking at
     * `chunkSize=1` means one auth prompt per package — do not use unless
     * you've accepted that cost. Prefer bumping `NODE_OPTIONS=--max-old-space-size`
     * first; reach for chunking only when heap alone can't contain the run.
     *
     * Other package managers ignore this option today.
     */
    chunkSize?: number;
    /**
     * When true, pnpm runs with `--loglevel=debug` and without the quiet
     * append-only reporter so every pre-publish step (graph build, registry
     * lookups, lifecycle scripts) is visible. Also toggles progress logs in
     * `syncInternalPeerVersions`.
     */
    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: 'bun' | 'npm' | '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.
     *
     * Returns an array of ScriptSteps so implementations can split the
     * publish into chunks (see {@link PublishOptions.chunkSize}) or emit a
     * single step. Callers pass the whole array to `runSteps` which executes
     * them sequentially and aggregates status.
     */
    publish(options?: PublishOptions): 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 BunPackageManager implements PackageManager {
    readonly command = "bun";
    readonly lockfile = "bun.lock";
    readonly name: "bun";
    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(_options?: PublishOptions): ScriptStep[];
    runInWorkspace(pkg: string, script: string, args?: string[]): ScriptStep;
    runXy(args: string[]): ScriptStep;
    versionApply(): ScriptStep;
    versionBump(type: 'major' | 'minor' | 'patch' | 'prerelease'): ScriptStep[];
}

type PackageManagerName$2 = 'bun' | 'npm' | 'pnpm' | 'yarn';
declare function detectPackageManager(): PackageManagerName$2;

declare function detectReact(): boolean;

declare class NpmPackageManager implements PackageManager {
    readonly command = "npm";
    readonly lockfile = "package-lock.json";
    readonly name: "npm";
    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(_options?: PublishOptions): ScriptStep[];
    runInWorkspace(pkg: string, script: string, args?: string[]): ScriptStep;
    runXy(args: string[]): ScriptStep;
    versionApply(): ScriptStep;
    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(options?: PublishOptions): 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$2): PackageManager;

declare function resolveWorkspace(workspaces: Workspace[], query: string): Workspace | undefined;

interface RootPackageJson {
    packageManager?: string;
    workspaces?: string[] | {
        packages?: string[];
    };
}
declare function readRootPackageJson(cwd?: string): RootPackageJson | undefined;
declare function readWorkspacePatternsFromPackageJson(cwd?: string): string[];
declare function readPnpmWorkspacePatterns(cwd?: string): string[];
declare function readWorkspacePatterns(cwd?: string): string[];
declare function listDeclaredWorkspaces(cwd?: string): Workspace[];
declare function detectPackageManagerFromPackageJson(cwd?: string): string | undefined;

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(_options?: PublishOptions): 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 DeplintCategory = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'workspace';
type DeplintFixKind = 'manifest';
type DeplintSection = 'dependencies' | 'devDependencies' | 'peerDependencies';
type DeplintFix = {
    action: 'add';
    dependency: string;
    detail: string;
    /**
     * Only meaningful when `section === 'peerDependencies'`.
     * `true` writes `peerDependenciesMeta[dependency].optional = true`.
     * `false` clears any existing optional flag.
     * `undefined` leaves `peerDependenciesMeta` untouched.
     */
    optional?: boolean;
    section: DeplintSection;
    version: string;
} | {
    action: 'move';
    dependency: string;
    detail: string;
    fromSection: DeplintSection;
    /** Same semantics as `add.optional`; only meaningful when `toSection === 'peerDependencies'`. */
    optional?: boolean;
    toSection: DeplintSection;
    version?: string;
} | {
    action: 'remove';
    dependency: string;
    detail: string;
    section: DeplintSection;
} | {
    action: 'set-version';
    dependency: string;
    detail: string;
    section: DeplintSection;
    version: string;
} | {
    /**
     * Pending intent: "the installed peer doesn't satisfy the range that the
     * requiring dep's current registry version declares — bump this dep to
     * whichever published version accepts the installed peer." Resolved into
     * a concrete `set-version` fix by `resolvePeerBumpFixes` before the
     * fix applier runs.
     */
    action: 'resolve-peer-bump';
    currentRange: string;
    /** The requiring dep whose range in our package.json should be bumped. */
    dependency: string;
    detail: string;
    /** Version of the peer currently installed (what we need to accept). */
    installedPeerVersion: string;
    /** The peer that isn't satisfied (for logging only). */
    peer: string;
    section: DeplintSection;
};
interface DeplintDiagnostic {
    data?: unknown;
    dependency?: string;
    evidence?: string[];
    file: string;
    fixable: boolean;
    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 only appear in `devDependencies` (moved out of dependencies/peerDependencies). */
    forceDevs: Set<string>;
    /**
     * User overrides for `peerDependenciesMeta[<name>].optional`. Presence
     * forces the value, absence falls back to the auto rule (every requiring
     * source marks the peer optional).
     */
    forcePeerOptional: Map<string, boolean>;
    /** 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>;
    /**
     * Exclude set used by `unusedPeerDependenciesRule`. Narrower than
     * `unusedDependencyExclude`: only peers reached via runtime chains (or
     * vouched for via `refType: 'dep' | 'peer'` / `peerOptional` override) are
     * preserved here. `forceDevs` is intentionally NOT included — a package
     * the user has classified as a devDep should be allowed to leave
     * `peerDependencies`.
     */
    unusedPeerDependencyExclude: Set<string>;
    workspace: Workspace;
    workspaceNames?: Set<string>;
}
interface DeplintReportInput {
    data?: unknown;
    dependency?: string;
    evidence?: string[];
    file?: string;
    message: string;
}
interface DeplintRuleContext extends DeplintWorkspaceContext {
    report: (diagnostic: DeplintReportInput) => void;
}
interface DeplintRuleMeta {
    description?: string;
    fixable?: DeplintFixKind[];
    severity: DeplintSeverity;
}
interface DeplintRule {
    category: DeplintCategory;
    evaluate: (context: DeplintRuleContext) => Promise<void> | void;
    id: string;
    meta: DeplintRuleMeta;
    resolveFixes?: (diagnostic: DeplintDiagnostic, context: DeplintWorkspaceContext) => Promise<DeplintFix[]> | DeplintFix[];
}
interface DeplintPlugin {
    name: string;
    rules: DeplintRule[];
}
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;
    fixableErrorCount: number;
    fixableWarningCount: number;
    problemCount: 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[];

/**
 * Determines if a package is "terminal" (an app, CLI, or website — not a
 * library that other packages will import).
 *
 * Terminal packages have unsatisfied runtime peers added to `dependencies`;
 * libraries get them in `peerDependencies` so consumers inherit the
 * requirement.
 *
 * Detection signals (any one is sufficient):
 *   1. `private: true` — unpublished apps.
 *   2. `xy.commands.deplint.terminal: true` — explicit opt-in for published
 *      apps/CLIs that can't use `private: true`.
 *   3. Bundled-CLI shape — `bin` present, no `main`/`module`, and `exports`
 *      either missing or limited to root + meta keys (`.`, `./package.json`,
 *      `./README.md`). The shape signal intentionally ignores `dependencies`
 *      so detection stays stable across `xy deplint --fix` runs (the fix
 *      mutates `dependencies`).
 */
declare function isTerminalPackage(location: string): boolean;

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)
 * - `dev`: must only appear in `devDependencies`; flagged as misplaced if found in `dependencies` or `peerDependencies`
 */
type DeplintRefType = 'dep' | 'dev' | 'peer';
/**
 * Per-package configuration within deplint.
 */
interface DeplintPackageConfig {
    /**
     * Force `peerDependenciesMeta[<name>].optional` when this package is added
     * to `peerDependencies`. Omit (default) to auto-derive from the requiring
     * dependencies' own `peerDependenciesMeta` — optional only when every
     * requiring source marks it optional.
     */
    peerOptional?: boolean;
    /** 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>;
    /**
     * Additional deplint rule plugins to load.
     * Entries may be package names, absolute paths, or paths relative to the
     * current working directory.
     */
    plugins?: string[];
    /**
     * Treat this package as terminal (an app or CLI, not a library).
     * Terminal packages send unsatisfied runtime peers to `dependencies`
     * instead of `peerDependencies`, and are exempt from the library
     * peer-promotion rule.
     *
     * Auto-detected when `private: true`, or when the package looks like a
     * bundled CLI (has `bin`, no `main`/`module`, and `exports` either
     * missing or limited to `.`/`./package.json`/`./README.md`). Set this
     * explicitly when neither auto-detection fires — e.g. a published CLI
     * with library-shaped exports.
     */
    terminal?: boolean;
}
/**
 * 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;
}
/**
 * Configuration for packman lint (package manager config linting).
 */
interface PackmanConfig {
    /**
     * Minimum age in minutes that a package must be published before pnpm will install it.
     * Only applies when pnpm is the detected package manager.
     * @default 4320 (3 days)
     */
    minimumReleaseAge?: number;
    /**
     * Package patterns to exclude from the minimumReleaseAge requirement.
     * These packages can be installed immediately upon release.
     * Supports exact names and scoped wildcards (e.g. '@myorg/*').
     * @default ["'@xylabs/*'", "'@xyo-network/*'"]
     */
    minimumReleaseAgeExclude?: string[];
}
/**
 * Command-specific configuration that cascades from root to package.
 * Settings here override the legacy top-level equivalents.
 */
interface CommandsConfig {
    deplint?: DeplintConfig;
    packman?: PackmanConfig;
    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;
            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<1 | 0>;

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>;

declare function loadDeplintRules(config?: DeplintConfig): Promise<DeplintRule[]>;

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 const builtInDeplintPlugin: DeplintPlugin;

declare function buildWorkspaceContext(workspace: Workspace, exclude?: Set<string>, workspaceNames?: Set<string>, forceDeps?: Set<string>, forcePeers?: Set<string>, forceDevs?: Set<string>, terminalOverride?: boolean, forcePeerOptional?: Map<string, boolean>): DeplintWorkspaceContext;

type DeployLevel = 'major' | 'minor' | 'patch' | 'prerelease';
declare function deploy(level?: DeployLevel): number;

declare const eject: () => number;

interface FixParams {
    jobs: number;
    pkg?: string;
    verbose?: boolean;
}
declare const fix: ({ jobs, pkg, verbose, }: FixParams) => 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 function gitlint(): number;

declare function gitlintFix(): number;

declare function install(): number;

declare const license: (pkg?: string) => Promise<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;

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) => 1 | 0;

interface OrphanParams {
    verbose?: boolean;
}
declare function orphanList({ verbose }?: OrphanParams): number;
declare function orphanClean({ verbose }?: OrphanParams): 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.
 *
 * With `verbose`, logs start/end markers and a per-workspace scan line so the
 * pre-publish phase isn't silent on large monorepos — otherwise it only logs
 * when it actually changes a peerDep, which can look hung on big repos.
 */
declare function syncInternalPeerVersions({ verbose }?: {
    verbose?: boolean;
}): 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;

type TargetPM = 'bun' | 'npm' | 'pnpm' | 'yarn';
interface ConvertParams {
    target: string;
    verbose?: boolean;
}
declare function detectCurrentPM(cwd: string): TargetPM | 'unknown';
declare function findWorkspacePackagePaths(cwd: string): string[];
declare function convert({ target, verbose }: ConvertParams): Promise<number>;

interface PackmanLintParams {
    fix?: boolean;
    verbose?: boolean;
}
declare function packmanLint({ fix, verbose }?: PackmanLintParams): Promise<number>;

type PackageManagerName$1 = 'bun' | 'npm' | 'pnpm' | 'yarn';
declare function rewriteScript(script: string, target: PackageManagerName$1): string;
declare function rewriteScriptsInPackageJson(pkg: Record<string, unknown>, target: PackageManagerName$1): 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>;

interface PublishParams {
    /**
     * If > 0, split the publish into chunks of this many workspaces. Each
     * chunk spawns a fresh package-manager process, capping memory use on
     * large monorepos. Default is 0 (disabled, single `pnpm publish -r` call).
     *
     * WARNING (pnpm): if your npm account requires interactive 2FA / web-login
     * per publish, each chunk triggers a fresh auth ceremony. At chunkSize=1
     * that's one prompt per package. Only enable if you've tried bumping
     * `NODE_OPTIONS=--max-old-space-size` and still OOM.
     */
    chunkSize?: number;
    verbose?: boolean;
}
declare const publish: ({ chunkSize, verbose }?: PublishParams) => 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: 'bun' | 'npm' | '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 checkResult: (name: string, result: number, level?: "error" | "warn", exitOnFail?: boolean) => void;

declare function applyPackageManager(content: string, pm: PackageManagerName$2): 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 function deprecationMigrate(oldPackage: string): Promise<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) => 1 | 0;

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>;

/**
 * Read a single git config value via `git config --get <key>`.
 *
 * Returns `undefined` when the key is unset (git exits with code 1) or git
 * itself is unavailable. Relying on the git CLI means we inherit git's native
 * resolution order — system, global, worktree, `include` directives, and the
 * optional `GIT_CONFIG_*` env overrides — rather than re-implementing any of
 * it.
 */
declare function getGitConfig(key: string): string | undefined;
/**
 * Read a git config value as a boolean via `git config --bool --get <key>`.
 *
 * Git normalizes `true`/`on`/`yes`/`1` to `true` and `false`/`off`/`no`/`0`
 * (plus the unset state) to `false`. We forward that normalization rather
 * than doing our own string compare. Returns `undefined` when the key is
 * unset so callers can distinguish "explicitly false" from "missing".
 */
declare function getGitConfigBool(key: string): boolean | undefined;
/**
 * Write a git config value via `git config <key> <value>`.
 * Inherits stdio so git's own output is visible to the caller.
 */
declare function setGitConfig(key: string, value: string): void;

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 fetchLatestPackageVersion(packageName: string): Promise<string | undefined>;
declare function clearLatestPackageVersionCache(): void;

type PackageManagerName = 'bun' | 'npm' | 'pnpm' | 'yarn';
type SupportedPlatform = 'darwin' | 'linux' | 'unknown' | 'win32';
interface PackageManagerInstallPlan {
    command?: string;
    manualInstructions: string[];
    packageManager: PackageManagerName;
    platform: SupportedPlatform;
    supported: boolean;
}
interface PackageManagerInstallContext {
    cwd?: string;
    operation: string;
    platform?: SupportedPlatform;
}
declare function isPackageManagerInstalled(pm: PackageManagerName): boolean;
declare function getPackageManagerInstallPlan(pm: PackageManagerName, platform?: SupportedPlatform): PackageManagerInstallPlan;
declare function ensurePackageManagerInstalled(pm: PackageManagerName, context: PackageManagerInstallContext): boolean;
interface PackageManagerStringSpawnOptions extends Omit<SpawnSyncOptionsWithStringEncoding, 'encoding'> {
    context: PackageManagerInstallContext;
    encoding?: BufferEncoding;
}
declare function spawnPackageManagerSync(pm: PackageManagerName, args: string[], options: PackageManagerStringSpawnOptions): SpawnSyncReturns<string>;

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 {
    depType: DepType;
    name: string;
    range: string;
    workspaceLocation: string;
    workspaceName: string;
}
interface RegistryInfo {
    distTags: Record<string, string>;
    versions: string[];
}
interface ResolvedDep {
    current: string;
    declaredRanges: string[];
    latest: string | undefined;
    name: string;
    next: string | undefined;
    preferredRangePrefix: '^' | '~';
    updateAvailable: boolean;
    wanted: string | undefined;
    workspaces: string[];
}
type VersionChoice = 'latest' | 'next' | 'skip' | 'wanted';
interface SelectedUpdate {
    name: string;
    targetRange: string;
    workspaces: string[];
}

declare function applyUpdates(cwd: string, workspaces: Workspace[], updates: SelectedUpdate[]): number;

declare function collectWorkspaceDeps(cwd: string, workspaces: Workspace[], workspaceNames: Set<string>): DeclaredDep[];

declare function fetchRegistryInfo(packageName: string): Promise<RegistryInfo>;
declare function fetchAllRegistryInfo(packageNames: string[], concurrency?: number): Promise<Map<string, RegistryInfo>>;

type Selection = -1 | 0 | 1 | 2;
type VersionClass = 'green' | 'yellow' | 'red' | 'gray';
declare function classifyVersion(version: string | undefined, current: string | undefined, mixedBaseline?: string): VersionClass;
declare function defaultSelection(dep: ResolvedDep): Selection;
declare function interactiveSelect(deps: ResolvedDep[]): Promise<SelectedUpdate[]>;

declare function renderTable(deps: ResolvedDep[]): void;

declare function resolveVersions(deps: DeclaredDep[], registry: Map<string, RegistryInfo>): 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;

export { ALL_PUBLINT_CHECKS, type BuildParams, BunPackageManager, CROSS_PLATFORM_NEWLINE, type CleanPackageParams, type CleanParams, type CommandsConfig, type CompileConfig, type CompileParams, type ConvertParams, type CopyAssetsParams, type CycleEdge, DEFAULT_README_BODY, DEFAULT_README_TEMPLATE, type DeclaredDep, type DepLintOptions, type DepType, type DeplintAppliedFix, type DeplintCategory, type DeplintConfig, type DeplintDiagnostic, type DeplintFix, type DeplintFixKind, type DeplintPackageConfig, DeplintPackageEditor, type DeplintPlugin, type DeplintRefType, type DeplintReportInput, type DeplintReporter, type DeplintRule, type DeplintRuleContext, type DeplintRuleMeta, type DeplintRunOptions, type DeplintRunResult, type DeplintSection, type DeplintSeverity, type DeplintSummary, type DeplintWorkspaceContext, type DeployLevel, DuplicateDetector, type DynamicShareConfig, type EntryMode, type FixParams, type GenDocsPackageParams, type GenDocsParams, INIT_CWD, LEGACY_COMMANDS_PREFIX, type LintInitParams, type LintNextParams, type LintPackageParams, type LintParams, type LintResult, type LiveShareConfig, NpmPackageManager, type OrphanParams, PUBLISH_ONLY_CHECKS, type PackageCompileTscConfig, type PackageCompileTsupConfig, type PackageCopyAssetsParams, type PackageJsonEx, type PackageManager, type PackageManagerInstallContext, type PackageManagerInstallPlan, type PackageManagerName$2 as PackageManagerName, type PackageManagerStringSpawnOptions, type PackagePublintParams, type PackmanCleanParams, type PackmanConfig, type PackmanLintParams, type PathConfig, PnpmPackageManager, type PublintCheckName, type PublintConfig, type PublintPackageParams, type PublintParams, type PublishOptions, type PublishParams, 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 RootPackageJson, type ScriptStep, type SelectedUpdate, type Selection, type SettingsLevel, type SupportedPlatform, 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, builtInDeplintPlugin, checkInternalDepVersions, checkInternalPeerVersions, checkResult, checkVersionConsistency, checkWorkspaceProtocol, classifyVersion, claudeCheck, claudeClean, claudeCommandTemplates, claudeCommands, claudeMdLocalTemplate, claudeMdProjectTemplate, claudeMdRuleTemplates, claudeRules, claudeSettings, claudeSkillTemplates, claudeSkills, clean, cleanAll, cleanDocs, cleanESLint, cleanPackage, clearLatestPackageVersionCache, collectWorkspaceDeps, compile, compileAll, compilePackage, convert, copyAssets, createBuildConfig, dead, defaultBuildConfig, defaultReadFileSyncOptions, defaultSelection, deleteGlob, deplint, deplintRules, deploy, deprecationMigrate, detectCurrentPM, detectDuplicateDependencies, detectPackageManager, detectPackageManagerFromPackageJson, detectReact, detectReactInMonorepo, detectWorkspaceCycles, eject, empty, ensurePackageManagerInstalled, fetchAllRegistryInfo, fetchLatestPackageVersion, fetchRegistryInfo, fillTemplate, findWorkspacePackagePaths, fix, fixInternalDepVersions, fixInternalPeerVersions, fixVersionConsistency, fixWorkspaceProtocol, genDocs, genDocsAll, genDocsPackage, generateIgnoreFiles, generateReadmeFiles, getDeplintReporter, getGitConfig, getGitConfigBool, getPackageManager, getPackageManagerInstallPlan, gitignore, gitignoreGen, gitignoreTemplate, gitlint, gitlintFix, humanDeplintReporter, install, installOutputCapture, interactiveSelect, isPackageManagerInstalled, isTerminalPackage, isYarnVersionOrGreater, jsonDeplintReporter, latestVersions, license, lint, lintAllPackages, lintInit, lintNext, lintPackage, lintlint, listDeclaredWorkspaces, listRepoTemplates, loadConfig, loadDeplintRules, loadPackageConfig, loadPublintOptions, loadRepoTemplateFiles, loadWorkspaceCommandConfig, logMonorepoVersion, multiLineToJSONArray, notEmpty, npmignoreGen, orphanClean, orphanList, outputStorage, packageClean, packageCleanOutputs, packageCleanTypescript, packageCompile, packageCompileTsc, packageCompileTsup, packageCopyAssets, packageGenDocs, packageLint, packageLintMonorepo, packageName, packagePublint, packageRecompile, packmanClean, packmanLint, parsedPackageJSON, printWorkspaceCycles, processEx, publint, publintAll, publintSingle, publish, test$1 as reactTest, readLines, readNonEmptyLines, readPnpmWorkspacePatterns, readRootPackageJson, readWorkspacePatterns, readWorkspacePatternsFromPackageJson, readmeGen, readmeInit, readmeLint, rebuild, recompile, recompileAll, recompilePackage, registerPackageManager, reinstall, relint, relintAllPackages, relintPackage, renderTable, repoInit, resolveTemplatePath, resolveVersions, resolveWorkspace, retest, rewriteScript, rewriteScriptsInPackageJson, runDeplint, runInstall, runStepAsync, runSteps, runStepsAsync, runUpdo, runWithConcurrency, runXy, runXyWithWarning, safeExit, safeExitAsync, scaffoldTemplate, setGitConfig, sitemap, sonar, spawnPackageManagerSync, start, statics, syncInternalPeerVersions, test, tryReadFileSync, tryRunLocalScript, tsupOptions, union, up, updo, withErrnoException, withError, writeLines, xy, xyBase, xyBuildCommands, xyCommonCommands, xyDeployCommands, xyInstallCommands, xyLintCommands, xyParseOptions, xyReactCommands, yarnWorkspace, yarnWorkspaces };
