/**
 * Object form of the `workspaces` field in package.json
 * (the alternative to an array of glob patterns).
 */
interface WorkspacesObject {
    /** Array of workspace glob patterns */
    packages: string[];
}
/**
 * Package.json structure.
 */
interface PackageJson {
    /** Package name */
    name?: string;
    /** Package version */
    version?: string;
    /** Package description */
    description?: string;
    /** Main entry point */
    main?: string;
    /** Module entry point */
    module?: string;
    /** Browser entry point */
    browser?: string;
    /** Types entry point */
    types?: string;
    /** Binary commands */
    bin?: string | Record<string, string>;
    /** Scripts */
    scripts?: Record<string, string>;
    /** Production dependencies */
    dependencies?: Record<string, string>;
    /** Development dependencies */
    devDependencies?: Record<string, string>;
    /** Peer dependencies */
    peerDependencies?: Record<string, string>;
    /** Optional dependencies */
    optionalDependencies?: Record<string, string>;
    /** Workspaces configuration */
    workspaces?: string[] | WorkspacesObject;
    /** Exports map */
    exports?: Record<string, unknown>;
    /** Engines */
    engines?: Record<string, string>;
    /** Allow additional fields */
    [key: string]: unknown;
}
/**
 * Reads and parses package.json from a directory, validating
 * the structure and normalizing fields to the PackageJson interface.
 *
 * @param projectPath - Project directory path or path to package.json
 * @returns Parsed package.json
 * @throws {Error} Error if file doesn't exist or is invalid
 *
 * @example Reading package.json
 * ```typescript
 * import { readPackageJson } from '@hyperfrontend/project-scope'
 *
 * const pkg = readPackageJson('/path/to/project')
 * console.log(pkg.name, pkg.version)
 * ```
 */
declare function readPackageJson(projectPath: string): PackageJson;
/**
 * Attempts to read and parse package.json if it exists,
 * returning null on missing file or parse failure.
 *
 * @param projectPath - Project directory path or path to package.json
 * @returns Parsed package.json or null if not found
 *
 * @example Reading package.json if it exists
 * ```typescript
 * import { readPackageJsonIfExists } from '@hyperfrontend/project-scope'
 *
 * const pkg = readPackageJsonIfExists('/path/to/project')
 * if (pkg) {
 *   console.log('Found:', pkg.name)
 * }
 * ```
 */
declare function readPackageJsonIfExists(projectPath: string): PackageJson | null;
/**
 * Find nearest package.json by walking up the directory tree.
 *
 * @param startPath - Starting path
 * @returns Path to directory containing package.json, or null if not found
 *
 * @example Finding nearest package.json
 * ```typescript
 * import { findNearestPackageJson } from '@hyperfrontend/project-scope'
 *
 * const pkgDir = findNearestPackageJson('./src/deep/nested/file.ts')
 * // => '/path/to/project'
 * ```
 */
declare function findNearestPackageJson(startPath: string): string | null;

/**
 * Map of dependency name to version.
 */
type DependencyMap = Record<string, string>;
/**
 * All dependencies categorized.
 */
interface AllDependencies {
    /** Production dependencies */
    dependencies: DependencyMap;
    /** Development dependencies */
    devDependencies: DependencyMap;
    /** Peer dependencies */
    peerDependencies: DependencyMap;
    /** Optional dependencies */
    optionalDependencies: DependencyMap;
}
/**
 * Extract all dependencies from package.json.
 *
 * @param packageJson - Parsed package.json
 * @returns All dependencies categorized
 *
 * @example Extracting all dependencies
 * ```typescript
 * import { getDependencies } from '@hyperfrontend/project-scope'
 *
 * const deps = getDependencies(packageJson)
 * console.log('Runtime:', Object.keys(deps.dependencies))
 * console.log('Dev:', Object.keys(deps.devDependencies))
 * ```
 */
declare function getDependencies(packageJson: PackageJson): AllDependencies;
/**
 * Get production dependencies only.
 *
 * @param packageJson - Parsed package.json
 * @returns Map of dependency name to version for runtime dependencies
 *
 * @example Getting production dependencies
 * ```typescript
 * import { getProductionDependencies } from '@hyperfrontend/project-scope'
 *
 * const prodDeps = getProductionDependencies(packageJson)
 * // => { 'express': '^4.18.0', 'lodash': '^4.17.21' }
 * ```
 */
declare function getProductionDependencies(packageJson: PackageJson): DependencyMap;
/**
 * Get development dependencies only.
 *
 * @param packageJson - Parsed package.json
 * @returns Map of dependency name to version for dev-time dependencies
 *
 * @example Getting development dependencies
 * ```typescript
 * import { getDevDependencies } from '@hyperfrontend/project-scope'
 *
 * const devDeps = getDevDependencies(packageJson)
 * // => { 'jest': '^29.0.0', 'typescript': '^5.0.0' }
 * ```
 */
declare function getDevDependencies(packageJson: PackageJson): DependencyMap;
/**
 * Get peer dependencies only.
 *
 * @param packageJson - Parsed package.json
 * @returns Map of dependency name to version for peer requirements
 *
 * @example Getting peer dependencies
 * ```typescript
 * import { getPeerDependencies } from '@hyperfrontend/project-scope'
 *
 * const peerDeps = getPeerDependencies(packageJson)
 * // => { 'react': '^18.0.0', 'react-dom': '^18.0.0' }
 * ```
 */
declare function getPeerDependencies(packageJson: PackageJson): DependencyMap;
/**
 * Get all dependencies merged into a single map.
 *
 * @param packageJson - Parsed package.json
 * @returns All dependencies merged
 *
 * @example Getting all merged dependencies
 * ```typescript
 * import { getAllDependencies } from '@hyperfrontend/project-scope'
 *
 * const allDeps = getAllDependencies(packageJson)
 * if ('typescript' in allDeps) {
 *   console.log('TypeScript version:', allDeps['typescript'])
 * }
 * ```
 */
declare function getAllDependencies(packageJson: PackageJson): DependencyMap;
/**
 * Check if package has a dependency of any type.
 *
 * @param packageJson - Parsed package.json content
 * @param name - Name of the dependency to check
 * @param depTypes - Optional array of dependency types to check (defaults to all)
 * @returns True if dependency exists in specified categories
 *
 * @example Checking for a dependency
 * ```typescript
 * import { hasDependency } from '@hyperfrontend/project-scope'
 *
 * // Check any dependency type
 * hasDependency(packageJson, 'lodash')
 *
 * // Check only production dependencies
 * hasDependency(packageJson, 'lodash', ['dependencies'])
 * ```
 */
declare function hasDependency(packageJson: PackageJson, name: string, depTypes?: ('dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies')[]): boolean;
/**
 * Get version string of a specific dependency.
 *
 * @param packageJson - Parsed package.json content
 * @param name - Name of the dependency to look up
 * @returns Version string or null if not found
 *
 * @example Getting dependency version
 * ```typescript
 * import { getDependencyVersion } from '@hyperfrontend/project-scope'
 *
 * const version = getDependencyVersion(packageJson, 'react')
 * // => '^18.2.0' or null
 * ```
 */
declare function getDependencyVersion(packageJson: PackageJson, name: string): string | null;
/**
 * Get workspace patterns from package.json.
 *
 * @param packageJson - Parsed package.json
 * @returns Array of workspace patterns or empty array
 *
 * @example Getting workspace patterns
 * ```typescript
 * import { getWorkspaces } from '@hyperfrontend/project-scope'
 *
 * const patterns = getWorkspaces(packageJson)
 * // => ['packages/*', 'apps/*']
 * ```
 */
declare function getWorkspaces(packageJson: PackageJson): string[];
/**
 * Check if package has workspaces configured (monorepo).
 *
 * @param packageJson - Parsed package.json
 * @returns True if workspaces are defined
 *
 * @example Checking for workspaces
 * ```typescript
 * import { hasWorkspaces } from '@hyperfrontend/project-scope'
 *
 * if (hasWorkspaces(packageJson)) {
 *   console.log('This is a monorepo')
 * }
 * ```
 */
declare function hasWorkspaces(packageJson: PackageJson): boolean;
/**
 * Check if a package is installed in node_modules.
 *
 * @param projectPath - Project root directory
 * @param packageName - Package name to check
 * @returns Boolean indicating whether the package exists in node_modules
 *
 * @example Checking installed packages
 * ```typescript
 * import { hasInstalledPackage } from '@hyperfrontend/project-scope'
 *
 * if (hasInstalledPackage('/project', 'typescript')) {
 *   console.log('TypeScript is installed')
 * }
 * ```
 */
declare function hasInstalledPackage(projectPath: string, packageName: string): boolean;

export { findNearestPackageJson, getAllDependencies, getDependencies, getDependencyVersion, getDevDependencies, getPeerDependencies, getProductionDependencies, getWorkspaces, hasDependency, hasInstalledPackage, hasWorkspaces, readPackageJson, readPackageJsonIfExists };
export type { AllDependencies, DependencyMap, PackageJson };