import type { MDXContent, SlugCasing } from '@renoun/mdx';
import { type GetEditorUriOptions } from '../utils/get-editor-uri.ts';
import { type OutlineRange } from '../utils/get-outline-ranges.ts';
import type { FileExportStaticMetadata, ModuleExport as JavaScriptFileExportMetadata } from '../utils/get-file-exports.ts';
import { type IsJavaScriptLikeExtension, type HasJavaScriptLikeExtensions } from '../utils/is-javascript-like-extension.ts';
import { type PathLike } from '../utils/path.ts';
import type { Kind, TypeFilter } from '../utils/resolve-type.ts';
import type { FileSystem, FileSystemWriteFileContent, FileWritableStream } from './FileSystem.ts';
import { type Cache } from './Cache.ts';
import { Repository, type RepositoryInput, type Release, type GetFileUrlOptions, type GetReleaseOptions, type GetReleaseUrlOptions } from './Repository.ts';
import { Session } from './Session.ts';
import { type GlobModuleMap } from './loader-core.ts';
import { type DirectorySchema, type DirectorySchemaOption, type ModuleExportValidator } from './schema.ts';
import type { StandardSchemaV1 } from './standard-schema.ts';
import type { DirectoryStructure, ExtractFileExtension, FileStructure, ModuleExportStructure, ContentSection, Section, GitMetadata, StructureOptions } from './types.ts';
import { type NormalizedStructureOptions } from './structure-options.ts';
/** A function that resolves the module runtime. */
type ModuleRuntimeResult<Value> = Value | Promise<Value> | (() => Value | Promise<Value>);
type ModuleRuntimeLoader<Value> = (path: string, file: File<any> | JavaScriptFile<any> | MarkdownFile<any> | MDXFile<any>) => ModuleRuntimeResult<Value>;
/** A record of named exports in a module. */
type ModuleExports<Value = unknown> = {
    [exportName: string]: Value;
};
type NormalizeModuleTypes<Types> = IsAny<Types> extends true ? UnknownModuleExports : Types extends ModuleExports ? Types : Types extends object ? Types : UnknownModuleExports;
export type { ContentSection, DirectoryStructure, FileStructure, FileSystemStructure, FileSystemStructureKind, ModuleExportStructure, PackageStructure, Section, WorkspaceStructure, } from './types.ts';
type SourceReleaseOptions = GetReleaseOptions & {
    repository?: RepositoryInput;
};
type SourceReleaseUrlOptions = GetReleaseUrlOptions & {
    repository?: RepositoryInput;
};
export type { DirectorySchema, DirectorySchemaOption, ModuleExportValidator, } from './schema.ts';
/** Utility type that infers the schema output from validator functions or a [Standard Schema](https://github.com/standard-schema/standard-schema?tab=readme-ov-file#standard-schema-spec). */
export type InferModuleExports<Exports> = {
    [ExportName in keyof Exports]: Exports[ExportName] extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Exports[ExportName]> : Exports[ExportName] extends ModuleExportValidator<any, infer Output> ? Output : Exports[ExportName];
};
type Merge<A, B> = Omit<A, keyof B> & B;
type MergeRecord<A, B> = {
    [K in keyof A | keyof B]: K extends keyof B ? K extends keyof A ? Merge<A[K], B[K]> : B[K] : K extends keyof A ? A[K] : never;
};
type KnownSchemaExtension = 'js' | 'jsx' | 'ts' | 'tsx' | 'md' | 'mdx' | 'json';
type IsSchemaByExtension<Schema> = Schema extends Record<string, any> ? Extract<keyof Schema, KnownSchemaExtension> extends never ? false : true : false;
type InferDirectorySchemaOptionTypes<Option> = Option extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Option> extends Record<string, any> ? StandardSchemaV1.InferOutput<Option> : {} : Option extends Record<string, any> ? InferModuleExports<Option> extends Record<string, any> ? InferModuleExports<Option> : {} : {};
type InferDirectorySchemaTypes<Schema> = [Schema] extends [undefined] ? {} : [Schema] extends [DirectorySchema] ? DirectorySchema extends Schema ? {} : IsSchemaByExtension<Schema> extends true ? {
    [Extension in Extract<keyof Schema, string>]: InferDirectorySchemaOptionTypes<Schema[Extension]>;
} : Record<string, InferDirectorySchemaOptionTypes<Schema>> : {};
type ApplyDirectorySchema<LoaderTypes extends Record<string, any>, Schema extends DirectorySchema | undefined> = MergeRecord<LoaderTypes, InferDirectorySchemaTypes<Schema>>;
type ApplyFileSchemaOption<Types extends Record<string, any>, SchemaOption extends DirectorySchemaOption | undefined> = MergeRecord<Types, SchemaOption extends DirectorySchemaOption ? InferDirectorySchemaOptionTypes<SchemaOption> : {}>;
/** A module loader runtime function. */
type ModuleLoader<Exports extends ModuleExports = ModuleExports> = ModuleRuntimeLoader<Exports>;
/** A record of loaders for different file extensions. */
export type ModuleLoaders = {
    [extension: string]: ModuleLoader;
};
type DirectoryLoader = ModuleLoaders | ModuleRuntimeLoader<any> | GlobModuleMap;
type UnknownModuleExports = {
    [exportName: string]: unknown;
};
type HasConcreteSchema<Schema extends DirectorySchema | undefined> = [
    Schema
] extends [DirectorySchema] ? DirectorySchema extends Schema ? false : true : false;
type WithUnknownExportsIfNoConcreteSchema<Schema extends DirectorySchema | undefined, Types> = Types extends Record<string, any> ? HasConcreteSchema<Schema> extends true ? Types : Types & UnknownModuleExports : HasConcreteSchema<Schema> extends true ? {} : UnknownModuleExports;
type InferDirectoryTypesFromLoaders<Loaders extends DirectoryLoader> = DirectoryLoader extends Loaders ? {} : InferDirectoryLoaderTypes<Loaders>;
type ResolveDirectoryTypes<LoaderTypes extends Record<string, any>, Loaders extends DirectoryLoader, Schema extends DirectorySchema | undefined> = ApplyDirectorySchema<MergeRecord<LoaderTypes, InferDirectoryTypesFromLoaders<Loaders>>, Schema>;
type InferDirectoryLoaderTypes<Loader extends DirectoryLoader> = Loader extends ModuleRuntimeLoader<infer RuntimeTypes> ? Record<string, NormalizeModuleTypes<RuntimeTypes>> : Loader extends GlobModuleMap<infer GlobTypes> ? Record<string, NormalizeModuleTypes<GlobTypes>> : Loader extends ModuleLoaders ? InferModuleLoadersTypes<Loader> : never;
type IsAny<Type> = 0 extends 1 & Type ? true : false;
/** Infer the type of a loader based on its runtime return type. */
type InferModuleLoaderTypes<Loader extends ModuleLoader> = Loader extends ModuleRuntimeLoader<infer Types> ? NormalizeModuleTypes<Types> : never;
/**
 * Frontmatter parsed from the markdown file. When using the default
 * loaders this is populated automatically (if present), and custom
 * loaders can further narrow this shape via `schema`.
 */
export type Frontmatter = Record<string, unknown>;
/** Default module types for common file extensions. */
export interface DefaultModuleTypes {
    md: {
        default: MDXContent;
        frontmatter?: Frontmatter;
    };
    mdx: {
        default: MDXContent;
        frontmatter?: Frontmatter;
    };
    json: JSONObject;
}
/** Merge default module types with custom types. */
export type WithDefaultTypes<Types> = IsAny<Types> extends true ? DefaultModuleTypes : MergeRecord<DefaultModuleTypes, Types>;
/** Infer default extension types for a file extension. */
type InferDefaultModuleTypes<Extension extends string> = Extension extends keyof DefaultModuleTypes ? DefaultModuleTypes[Extension] : ModuleExports;
type JavaScriptFileExtensionTypes<Extension extends string, DirectoryTypes extends Record<string, any>> = Extension extends keyof DirectoryTypes ? Extension extends keyof DefaultModuleTypes ? InferDefaultModuleTypes<Extension> & DirectoryTypes[Extension] extends Record<string, any> ? InferDefaultModuleTypes<Extension> & DirectoryTypes[Extension] : ModuleExports : DirectoryTypes[Extension] extends Record<string, any> ? DirectoryTypes[Extension] : ModuleExports : InferDefaultModuleTypes<Extension>;
type ExtensionElement<Extension> = Extension extends readonly (infer E)[] ? Extract<E, string> : Extract<Extension, string>;
/** Infer extension types for all loaders in a module. */
type InferModuleLoadersTypes<Loaders extends ModuleLoaders> = {
    [Extension in keyof Loaders]: Extension extends keyof DefaultModuleTypes ? Merge<Merge<DefaultModuleTypes[Extension], InferModuleLoaderTypes<Loaders[Extension]>>, Extension extends 'md' | 'mdx' ? {
        default: MDXContent;
    } : {}> : InferModuleLoaderTypes<Loaders[Extension]>;
};
/** Extract keys from runtime‑capable loaders. */
type LoadersWithRuntimeKeys<Loaders> = Extract<keyof Loaders, 'js' | 'jsx' | 'ts' | 'tsx' | 'md' | 'mdx'>;
/** Error for when a file is not found. */
export declare class FileNotFoundError extends Error {
    constructor(path: string | string[], extension?: any, context?: {
        /** Directory path (relative to workspace) where the lookup started. */
        directoryPath?: string;
        /** Absolute directory path (useful in server builds). */
        absoluteDirectoryPath?: string;
        /** Root path used by the Directory (relative to workspace). */
        rootPath?: string;
        /** Nearby entries at the point of failure (base names only). */
        nearestCandidates?: string[];
    });
}
/** A directory or file entry. */
export type FileSystemEntry<DirectoryTypes extends Record<string, any> = any, Extension = undefined> = Directory<DirectoryTypes> | FileWithExtension<DirectoryTypes, Extension>;
export interface NavigationEntry<Entry extends FileSystemEntry<any> = FileSystemEntry<any>> {
    entry: Entry;
    children?: NavigationEntry<Entry>[];
}
/** Options for the `File#getPathname` and `File#getPathnameSegments` methods. */
export interface FilePathnameOptions {
    /** Whether to include the configured `Directory:options.basePathname` in the pathname. */
    includeBasePathname?: boolean;
    /** Whether to include the directory named segment in the pathname segments e.g. `button/button` for `Button/Button.tsx`. */
    includeDirectoryNamedSegment?: boolean;
}
/** Options for a file in the file system. */
export interface FileOptions<Types extends Record<string, any> = Record<string, any>, Path extends string = string, SchemaOption extends DirectorySchemaOption | undefined = undefined> {
    /** The path to the file. */
    path: Path | URL;
    /** The base pathname to use for the file. */
    basePathname?: string | null;
    /** The slug casing to use for the file. */
    slugCasing?: SlugCasing;
    /** The depth of the file in the file system. */
    depth?: number;
    /** Optional schema for this file (overrides the parent directory schema). */
    schema?: SchemaOption;
    /**
     * Known byte length for the file contents.
     *
     * When omitted, `File` will ask the `FileSystem` for the file size synchronously.
     * If the size cannot be determined synchronously, the constructor will throw.
     */
    byteLength?: number;
    /** The directory to use for the file. */
    directory?: PathLike | Directory<Types, WithDefaultTypes<Types>, DirectoryLoader, undefined>;
    /** The repository to use for git operations and source URLs. */
    repository?: RepositoryInput;
    /** Optional cache provider for directory/session-level caching. */
    cache?: Cache;
}
/** A file in the file system. */
export declare class File<DirectoryTypes extends Record<string, any> = Record<string, any>, Path extends string = string, Extension extends string = ExtractFileExtension<Path>> {
    #private;
    constructor(options: FileOptions<DirectoryTypes, Path, any>);
    /** The last modified time of the file in milliseconds. */
    get lastModified(): number;
    /** The intrinsic name of the file. */
    get name(): string;
    /** The base name of the file e.g. `index` in `index.ts`. */
    get baseName(): string;
    /** The modifier name of the file if defined e.g. `test` in `index.test.ts`. */
    get kind(): string | undefined;
    /** The base file name formatted as a title. */
    get title(): string;
    /** The order of the file if defined. */
    get order(): string | undefined;
    /** The extension of the file if defined. */
    get extension(): Extension;
    /** Get the depth of the file starting from the root directory. */
    get depth(): number;
    /** Get the schema configuration for this file if defined. */
    get schema(): DirectorySchemaOption | undefined;
    /** Get the slug of the file. */
    get slug(): string;
    /**
     * Get the path of this file formatted for routes. The configured `slugCasing`
     * option will be used to format each segment.
     */
    getPathname(options?: FilePathnameOptions): string;
    /** Get the route path segments for this file. */
    getPathnameSegments(options?: FilePathnameOptions): string[];
    /** The file path relative to the root directory. */
    get relativePath(): string;
    /** The file path relative to the workspace root. */
    get workspacePath(): string;
    /** The absolute file system path. */
    get absolutePath(): string;
    /** MIME type inferred from file extension. */
    get type(): string;
    /** Get the URL to the file git blame for the configured git repository. */
    getBlameUrl(options?: Pick<GetFileUrlOptions, 'ref'> & {
        repository?: RepositoryInput;
    }): string;
    /** Get the edit URL to the file source for the configured git repository. */
    getEditUrl(options?: Pick<GetFileUrlOptions, 'ref' | 'line'> & {
        repository?: RepositoryInput;
    }): string;
    /** Get the URL to the file history for the configured git repository. */
    getHistoryUrl(options?: Pick<GetFileUrlOptions, 'ref'> & {
        repository?: RepositoryInput;
    }): string;
    /** Get the URL to the raw file contents for the configured git repository. */
    getRawUrl(options?: Pick<GetFileUrlOptions, 'ref'> & {
        repository?: RepositoryInput;
    }): string;
    /** Get the URL to the file source for the configured git repository. */
    getSourceUrl(options?: Pick<GetFileUrlOptions, 'ref' | 'line'> & {
        repository?: RepositoryInput;
    }): string;
    /** Get a release URL for the configured git repository. */
    getReleaseUrl(options?: SourceReleaseUrlOptions): Promise<string>;
    /** Retrieve metadata about a release for the configured git repository. */
    getRelease(options?: SourceReleaseOptions): Promise<Release>;
    /** Get the URI to the file source code for the configured editor. */
    getEditorUri(options?: Omit<GetEditorUriOptions, 'path'>): string;
    protected resolveSharedStructureGitMetadata(_structureOptions: NormalizedStructureOptions, _environment: 'production' | 'development'): Promise<GitMetadata | undefined>;
    protected resolveStructureCacheState(session: Session, structureOptions: NormalizedStructureOptions): Promise<{
        nodeKey: string;
        gitMetadata?: GitMetadata;
    }>;
    /** Get the first local git commit date of the file. */
    getFirstCommitDate(): Promise<Date | undefined>;
    /** Get the last local git commit date of the file. */
    getLastCommitDate(): Promise<Date | undefined>;
    /** Get the local git authors of the file. */
    getAuthors(): Promise<import("./types.ts").GitAuthor[]>;
    /** Get the parent directory containing this file. */
    getParent(): Directory<DirectoryTypes, WithDefaultTypes<DirectoryTypes>, DirectoryLoader, DirectorySchema | undefined, DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<WithDefaultTypes<DirectoryTypes>, DirectorySchema | undefined>, undefined>, ApplyDirectorySchema<WithDefaultTypes<DirectoryTypes>, DirectorySchema | undefined>> | undefined>;
    /**
     * Get the previous and next sibling entries (files or directories) of the parent directory.
     * If the file is an index or readme file, the siblings will be retrieved from the parent directory.
     */
    getSiblings<GroupTypes extends Record<string, any> = DirectoryTypes>(options?: {
        collection?: Collection<GroupTypes, FileSystemEntry<any>[]>;
        includeDirectoryNamedSegment?: boolean;
    }): Promise<[
        FileSystemEntry<DirectoryTypes> | undefined,
        FileSystemEntry<DirectoryTypes> | undefined
    ]>;
    protected getFileStructureBase(gitMetadata?: GitMetadata, structureOptions?: NormalizedStructureOptions): Promise<FileStructure>;
    protected buildStructureValue(normalizedOptions: NormalizedStructureOptions, gitMetadata?: GitMetadata, _mode?: 'cached' | 'manifest'): Promise<FileStructure>;
    getStructure(options?: StructureOptions): Promise<FileStructure>;
    /** Read the file contents as bytes. */
    bytes(): Promise<Uint8Array<ArrayBuffer>>;
    /** Create a readable stream for the file contents. */
    stream(): ReadableStream<Uint8Array<ArrayBuffer>>;
    /** Get the file size in bytes without reading the contents. */
    get size(): number;
    /** Read the file contents as text (UTF-8 decode, Blob semantics). */
    getText(): Promise<string>;
    /** Read the file contents as an ArrayBuffer. */
    arrayBuffer(): Promise<ArrayBuffer>;
    /** Slice the file contents without buffering. */
    slice(start?: number, end?: number, contentType?: string): Blob;
    /** Get the byte length of this file without reading the contents. */
    getByteLength(): Promise<number>;
    /** Write content to this file. */
    write(content: FileSystemWriteFileContent): Promise<void>;
    /** Create a writable stream for this file. */
    writeStream(): FileWritableStream;
    /** Delete this file from the file system. */
    delete(): Promise<void>;
    protected invalidateCachedValues(): void;
    /** Check if this file exists in the file system. */
    exists(): Promise<boolean>;
}
type JSONPrimitive = string | number | boolean | null;
interface JSONObject {
    [Key: string]: JSONValue;
}
export type JSONValue = JSONPrimitive | JSONValue[] | JSONObject;
export interface JSONFileOptions<Data extends Record<string, any> = JSONObject, DirectoryTypes extends Record<string, any> = Record<string, any>, Path extends string = string> extends FileOptions<DirectoryTypes, Path, any> {
    schema?: StandardSchemaV1<Data> | ((value: unknown) => Data);
}
type IsArray<Type> = Type extends readonly any[] ? true : Type extends any[] ? true : false;
type Element<Type> = Type extends readonly (infer Item)[] ? Item : Type extends (infer Item)[] ? Item : never;
type IsNumericString<String extends string> = String extends `${number}` ? true : false;
type JSONPathValueWithSegments<Data, Segments extends string[]> = Segments extends [] ? Data : Segments extends [infer Head extends string, ...infer Rest extends string[]] ? IsArray<Data> extends true ? IsNumericString<Head> extends true ? JSONPathValueWithSegments<Element<Data>, Rest> | undefined : undefined : Head extends keyof Data ? Rest['length'] extends 0 ? Data[Head] : JSONPathValueWithSegments<Data[Head], Rest> : undefined : never;
type JSONPathSegments<Path extends string> = Path extends `${infer Head}.${infer Rest}` ? [Head, ...JSONPathSegments<Rest>] : Path extends '' ? [] : [Path];
type JSONPathValue<Data, Path extends string> = JSONPathValueWithSegments<Data, JSONPathSegments<Path>>;
type JSONPropertyPath<Data> = IsArray<Data> extends true ? `${number}` | `${number}.${JSONPropertyPath<Element<Data>>}` : Data extends Record<string, any> ? Extract<keyof Data, string> | {
    [Key in Extract<keyof Data, string>]: IsArray<Data[Key]> extends true ? `${Key}.${number}` | `${Key}.${number}.${JSONPropertyPath<Element<Data[Key]>>}` : Data[Key] extends Record<string, any> ? `${Key}.${JSONPropertyPath<Data[Key]>}` : never;
}[Extract<keyof Data, string>] : never;
/** A JSON file in the file system. */
export declare class JSONFile<Data extends Record<string, any> = JSONObject, DirectoryTypes extends Record<string, any> = Record<string, any>, const Path extends string = string, Extension extends string = ExtractFileExtension<Path>> extends File<DirectoryTypes, Path, Extension> {
    #private;
    constructor(fileOptions: JSONFileOptions<Data, DirectoryTypes, Path>);
    /**
     * Get a value from the JSON data using dot notation.
     *
     * Returns `undefined` when the path cannot be resolved.
     */
    get(): Promise<Data>;
    get<Path extends JSONPropertyPath<Data>>(path: Path): Promise<JSONPathValue<Data, Path>>;
    protected invalidateCachedValues(): void;
}
/** Error for when a module export cannot be found. */
export declare class ModuleExportNotFoundError extends Error {
    constructor(path: string, name: string, className: string);
}
/** A JavaScript module export. */
export declare class ModuleExport<Value> {
    #private;
    constructor(name: string, file: JavaScriptFile<any>, loader?: ModuleLoader<any>, slugCasing?: SlugCasing, staticLocation?: JavaScriptFileExportMetadata);
    static init<Value>(name: string, file: JavaScriptFile<any>, loader?: ModuleLoader<any>, slugCasing?: SlugCasing, staticLocation?: JavaScriptFileExportMetadata): Promise<ModuleExport<Value>>;
    protected getStaticMetadata(): Promise<FileExportStaticMetadata | undefined>;
    /** Get the slug of the file export. */
    get slug(): string;
    /** Get the name of the export. Default exports will use the file name or declaration name if available. */
    get name(): string;
    clearCachedValues(): void;
    /** The export name formatted as a title. */
    get title(): string;
    /** Get the JSDoc description for the export. */
    get description(): string | undefined;
    /** Get the JSDoc tags for the export. */
    getTags({ includeTypes, }?: {
        /** Whether to include type-related tags e.g. `@param`, `@returns`, `@type`, etc. */
        includeTypes?: boolean;
    }): {
        name: string;
        text?: string;
    }[] | undefined;
    /** Get the environment of the export. */
    getEnvironment(): "server" | "client" | "isomorphic" | undefined;
    /**
     * Get the source text of the export, optionally including dependencies.
     *
     * Note, including dependencies can be expensive to calculate, only use when necessary.
     */
    getText({ includeDependencies, }?: {
        includeDependencies?: boolean;
    }): Promise<string>;
    /** Get the start and end position of the export in the file system. */
    getPosition(): import("../utils/get-declaration-location.ts").DeclarationPosition | undefined;
    /** Get the edit URL to the file export source for the configured git repository. */
    getEditUrl(options?: Pick<GetFileUrlOptions, 'ref'> & {
        repository?: Repository;
    }): string;
    /** Get the URL to the file export source for the configured git repository. */
    getSourceUrl(options?: Pick<GetFileUrlOptions, 'ref'> & {
        repository?: Repository;
    }): string;
    getReleaseUrl(options?: SourceReleaseUrlOptions): Promise<string>;
    getRelease(options?: SourceReleaseOptions): Promise<Release>;
    /** Get the URI to the file export source code for the configured editor. */
    getEditorUri(options?: Omit<GetEditorUriOptions, 'path'>): string;
    /** Get the first git commit date that touched this export. */
    getFirstCommitDate(): Promise<Date | undefined>;
    /** Get the last git commit date that touched this export. */
    getLastCommitDate(): Promise<Date | undefined>;
    /** Get the resolved type of the export. */
    getType(filter?: TypeFilter): Promise<Kind | undefined>;
    /** Attempt to return a literal value for this export if it can be determined statically. */
    getStaticValue(): Promise<Value>;
    /**
     * Get the runtime value of the export. An error will be thrown if the export
     * is not found or the configured schema validation for this file extension fails.
     */
    getRuntimeValue(): Promise<Value>;
    /**
     * Determine whether this export is a React component type.
     *
     * Uses cached runtime values when available (e.g. after calling
     * `getRuntimeValue()`), and falls back to a conservative name heuristic
     * otherwise.
     */
    isComponent(): boolean;
    /** Get the value of this export, preferring a static value and falling back to runtime if available. */
    getValue(): Promise<Value>;
    /**
     * Get the value of this export, returning the provided default value when the export is not found.
     */
    getValueWithDefault<DefaultValue extends Value>(defaultValue: DefaultValue): Promise<Value>;
    getStructure(options?: StructureOptions): Promise<ModuleExportStructure>;
}
/** Options for a JavaScript file in the file system. */
export interface JavaScriptFileOptions<Types extends Record<string, any>, DirectoryTypes extends Record<string, any>, Path extends string> extends FileOptions<DirectoryTypes, Path> {
    loader?: ModuleLoader<Types>;
}
/** A JavaScript file in the file system. */
export declare class JavaScriptFile<Types extends InferDefaultModuleTypes<Path> = any, DirectoryTypes extends Record<string, any> = Record<string, any>, const Path extends string = string, Extension extends string = ExtractFileExtension<Path>> extends File<DirectoryTypes, Path, Extension> {
    #private;
    constructor({ loader, ...fileOptions }: JavaScriptFileOptions<Types, DirectoryTypes, Path>);
    protected invalidateCachedValues(): void;
    /** Parse and validate an export value using the configured schema if available. */
    parseExportValue(name: string, value: any): any;
    protected resolveSharedStructureGitMetadata(structureOptions: NormalizedStructureOptions, environment: 'production' | 'development'): Promise<GitMetadata | undefined>;
    /** Get all resolved export types from the JavaScript file. */
    getExportTypes(filter?: TypeFilter): Promise<Kind[]>;
    /** Get all exports from the JavaScript file. */
    getExports(): Promise<ModuleExport<Types[Extract<keyof Types, string>]>[]>;
    /** Get the first local git commit date of the file. */
    getFirstCommitDate(): Promise<Date | undefined>;
    /** Get the last local git commit date of the file. */
    getLastCommitDate(): Promise<Date | undefined>;
    /** Get the local git authors of the file. */
    getAuthors(): Promise<import("./types.ts").GitAuthor[]>;
    /** Get a JavaScript file export by name. */
    getExport<const ExportName extends Extract<keyof Types, string>>(name: ExportName): Promise<ModuleExport<Types[ExportName]>>;
    /** Get a named export from the JavaScript file. */
    getNamedExport<const ExportName extends Extract<keyof Types, string>>(name: ExportName): Promise<ModuleExport<Types[ExportName]>>;
    /** Get the default export from the JavaScript file. */
    getDefaultExport(this: Types extends {
        default: infer _DefaultType;
    } ? JavaScriptFile<Types, DirectoryTypes, Path, Extension> : never): Promise<ModuleExport<Types extends {
        default: infer DefaultType;
    } ? DefaultType : never>>;
    /** Get the start position of an export in the JavaScript file. */
    getExportLocation(name: string): Promise<JavaScriptFileExportMetadata | undefined>;
    /** Get the runtime value of an export in the JavaScript file. */
    getExportValue<const ExportName extends Extract<keyof Types, string>>(name: ExportName): Promise<Types[ExportName]>;
    /** Get an outline derived from regions and exports in the JavaScript file. */
    getSections(): Promise<Section[]>;
    /** Get the outlining ranges in the JavaScript file. */
    getOutlineRanges(): Promise<OutlineRange[]>;
    /** Get foldable ranges in the JavaScript file (IDE-style folding). */
    getFoldingRanges(): Promise<OutlineRange[]>;
    protected buildStructureValue(normalizedOptions: NormalizedStructureOptions, gitMetadata?: GitMetadata, mode?: 'cached' | 'manifest'): Promise<FileStructure>;
    getStructure(options?: StructureOptions): Promise<FileStructure>;
    /** Check if an export exists in the JavaScript file statically or at runtime. */
    hasExport(name: string): Promise<boolean>;
}
/** An MDX file export. */
export declare class MDXModuleExport<Value> {
    #private;
    constructor(name: string, file: MDXFile<any>, loader?: ModuleLoader<any>, slugCasing?: SlugCasing, getModuleFn?: () => Promise<any>);
    get name(): string;
    get title(): string;
    clearCachedValues(): void;
    get slug(): string;
    getEditorUri(options?: Omit<GetEditorUriOptions, 'path'>): string;
    getEditUrl(options?: Pick<GetFileUrlOptions, 'ref'> & {
        repository?: Repository;
    }): string;
    getSourceUrl(options?: Pick<GetFileUrlOptions, 'ref'> & {
        repository?: Repository;
    }): string;
    getReleaseUrl(options?: SourceReleaseUrlOptions): Promise<string>;
    getRelease(options?: SourceReleaseOptions): Promise<Release>;
    /** Parse and validate an export value using the configured schema if available. */
    parseExportValue(name: string, value: any): any;
    /** Attempt to return a literal value for this export if it can be determined statically. */
    getStaticValue(): Promise<Value>;
    /**
     * Get the runtime value of the export. An error will be thrown if the export
     * is not found or the configured schema validation for the MDX file fails.
     */
    getRuntimeValue(): Promise<Value>;
    /** Get the value of this export, preferring a static value and falling back to runtime if available. */
    getValue(): Promise<Value>;
}
/** Options for an MDX file in the file system. */
export interface MDXFileOptions<Types extends Record<string, any>, DirectoryTypes extends Record<string, any>, Path extends string> extends FileOptions<DirectoryTypes, Path> {
    loader?: ModuleLoader<{
        default: MDXContent;
    } & Types>;
}
/** An MDX file in the file system. */
export declare class MDXFile<Types extends Record<string, any> = {
    default: MDXContent;
}, DirectoryTypes extends Record<string, any> = Record<string, any>, const Path extends string = string, Extension extends string = ExtractFileExtension<Path>> extends File<DirectoryTypes, Path, Extension> {
    #private;
    constructor({ loader, ...fileOptions }: MDXFileOptions<{
        default: MDXContent;
    } & Types, DirectoryTypes, Path>);
    protected invalidateCachedValues(): void;
    getText(options?: {
        includeFrontmatter?: boolean;
    }): Promise<string>;
    getFrontmatter(): Promise<Record<string, unknown> | undefined>;
    getChatGPTUrl(): Promise<string>;
    getClaudeUrl(): Promise<string>;
    getExports(): Promise<MDXModuleExport<any>[]>;
    getExport<const ExportName extends 'default' | Extract<keyof Types, string>>(name: ExportName): Promise<MDXModuleExport<({
        default: MDXContent;
    } & Types)[ExportName]>>;
    /** Get a named export from the MDX file. */
    getNamedExport<const ExportName extends Extract<keyof Types, string>>(name: ExportName): Promise<MDXModuleExport<Types[ExportName]>>;
    /** Get the default export from the MDX file. */
    getDefaultExport(): Promise<MDXContent>;
    /** Get the rendered MDX content. */
    getContent(): Promise<MDXContent>;
    /** Get sections parsed from the MDX content based on headings. */
    getSections(): Promise<ContentSection[]>;
    getStructure(options?: StructureOptions): Promise<FileStructure>;
    protected buildStructureValue(normalizedOptions: NormalizedStructureOptions, gitMetadata?: GitMetadata, _mode?: 'cached' | 'manifest'): Promise<FileStructure>;
    /** Check if an export exists at runtime in the MDX file. */
    hasExport(name: string): Promise<boolean>;
    /** Parse and validate an export value using the configured schema if available. */
    parseExportValue(name: string, value: any): any;
    /** Get the runtime value of an export in the MDX file. */
    getExportValue<const ExportName extends 'default' | Extract<keyof Types, string>>(name: ExportName): Promise<({
        default: MDXContent;
    } & Types)[ExportName]>;
    /** Attempt to return a literal value for a named export if it can be determined statically. */
    getStaticExportValue(name: string): Promise<unknown>;
}
/** Options for a Markdown file in the file system. */
export interface MarkdownFileOptions<Types extends Record<string, any>, DirectoryTypes extends Record<string, any>, Path extends string, SchemaOption extends DirectorySchemaOption | undefined = undefined> extends FileOptions<DirectoryTypes, Path, SchemaOption> {
    loader?: ModuleLoader<{
        default: MDXContent;
    } & Types>;
}
/** A Markdown file in the file system. */
export declare class MarkdownFile<Types extends Record<string, any> = {
    default: MDXContent;
}, DirectoryTypes extends Record<string, any> = Record<string, any>, const Path extends string = string, Extension extends string = ExtractFileExtension<Path>, SchemaOption extends DirectorySchemaOption | undefined = undefined> extends File<DirectoryTypes, Path, Extension> {
    #private;
    constructor({ loader, ...fileOptions }: MarkdownFileOptions<{
        default: MDXContent;
    } & Types, DirectoryTypes, Path, SchemaOption>);
    protected invalidateCachedValues(): void;
    getText(options?: {
        includeFrontmatter?: boolean;
    }): Promise<string>;
    getFrontmatter(): Promise<Record<string, unknown> | undefined>;
    getChatGPTUrl(): Promise<string>;
    getClaudeUrl(): Promise<string>;
    /** Get the rendered markdown content. */
    getContent(): Promise<MDXContent>;
    /** Get sections parsed from the markdown content based on headings. */
    getSections(): Promise<ContentSection[]>;
    getStructure(options?: StructureOptions): Promise<FileStructure>;
    protected buildStructureValue(normalizedOptions: NormalizedStructureOptions, gitMetadata?: GitMetadata, _mode?: 'cached' | 'manifest'): Promise<FileStructure>;
    /** Get the runtime value of an export in the Markdown file. (Permissive signature for union compatibility.) */
    parseExportValue(name: string, value: any): any;
    getExportValue<const ExportName extends 'default' | Extract<keyof ApplyFileSchemaOption<{
        default: MDXContent;
    } & Types, SchemaOption>, string>>(name: ExportName): Promise<ApplyFileSchemaOption<{
        default: MDXContent;
    } & Types, SchemaOption>[ExportName]>;
    /** Attempt to return a literal value for a named export if it can be determined statically. */
    getStaticExportValue(name: string): Promise<unknown>;
}
type Narrowed<Filter> = Filter extends (entry: any) => entry is infer ReturnType ? ReturnType : never;
type ResolveDirectoryFilterEntries<Filter, Types extends Record<string, any> = Record<string, any>> = Filter extends string ? Filter extends `**${string}` ? Directory<Types> | FileWithExtension<Types, ExtractFileExtension<Filter>> : FileWithExtension<Types, ExtractFileExtension<Filter>> : [Narrowed<Filter>] extends [never] ? FileSystemEntry<Types> : Narrowed<Filter>;
type DirectoryEntriesRecursiveOption<Filter> = Filter extends string ? Filter extends `**${string}` ? boolean : undefined : boolean;
type DirectoryEntriesBaseOptions<ProvidedFilter> = {
    /** Filter entries with a minimatch pattern or predicate. */
    filter?: ProvidedFilter;
    /** Include files named the same as their immediate directory (e.g. `Button/Button.tsx`). */
    includeDirectoryNamedFiles?: boolean;
    /** Include index and readme files. */
    includeIndexAndReadmeFiles?: boolean;
    /** Include files that are ignored by `.gitignore`. */
    includeGitIgnoredFiles?: boolean;
    /** Include files that are excluded by the configured `tsconfig.json` file's `exclude` patterns. */
    includeTsConfigExcludedFiles?: boolean;
    /** Include hidden files and directories (names starting with `.`). */
    includeHiddenFiles?: boolean;
};
type DirectoryFlatEntriesOptions<ProvidedFilter> = DirectoryEntriesBaseOptions<ProvidedFilter> & {
    /** Recursively walk every subdirectory. */
    recursive?: DirectoryEntriesRecursiveOption<ProvidedFilter>;
};
type NoInferType<T> = [T][T extends any ? 0 : never];
export type DirectoryFilter<Entry extends FileSystemEntry<any>, Types extends Record<string, any>> = ((entry: FileSystemEntry<Types>) => entry is Entry) | ((entry: FileSystemEntry<Types>) => Promise<boolean> | boolean) | string;
export interface BaseDirectoryOptions<Types extends Record<string, any> = {}, LoaderTypes extends WithDefaultTypes<Types> = WithDefaultTypes<Types>, Loaders extends DirectoryLoader = DirectoryLoader, Schema extends DirectorySchema | undefined = DirectorySchema | undefined, Filter extends DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined = DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined> {
    /** Directory path in the workspace. */
    path?: PathLike;
    /** Filter entries with a minimatch pattern or predicate. */
    filter?: Filter;
    /** Directory schema (global or per-extension). */
    schema?: Schema;
    /** Extension loaders, a runtime loader, or an `import.meta.glob(...)` map. */
    loader?: Loaders | (() => Loaders);
    /** Base route prepended to descendant `getPathname()` results. */
    basePathname?: string | null;
    /** Uses the closest `tsconfig.json` path for static analysis and type-checking. */
    tsConfigPath?: string;
    /** Slug casing applied to route segments. */
    slugCasing?: SlugCasing;
    /** Optional cache provider for directory/session-level caching. */
    cache?: Cache;
    /** Sort callback applied at *each* directory depth. */
    sort?: SortDescriptor<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, NoInferType<Schema>>>>;
}
export interface GitDirectoryOptions<Types extends Record<string, any> = {}, LoaderTypes extends WithDefaultTypes<Types> = WithDefaultTypes<Types>, Loaders extends DirectoryLoader = DirectoryLoader, Schema extends DirectorySchema | undefined = DirectorySchema | undefined, Filter extends DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined = DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined> extends BaseDirectoryOptions<Types, LoaderTypes, Loaders, Schema, Filter> {
    /** The repository used for git-backed operations. */
    repository?: RepositoryInput;
}
export interface FileSystemDirectoryOptions<Types extends Record<string, any> = {}, LoaderTypes extends WithDefaultTypes<Types> = WithDefaultTypes<Types>, Loaders extends DirectoryLoader = DirectoryLoader, Schema extends DirectorySchema | undefined = DirectorySchema | undefined, Filter extends DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined = DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined> extends BaseDirectoryOptions<Types, LoaderTypes, Loaders, Schema, Filter> {
    /** Custom file‑system adapter (escape hatch). */
    fileSystem: FileSystem;
    /** Optional repository for git-backed metadata and URLs. */
    repository?: RepositoryInput;
}
export type DirectoryOptions<Types extends Record<string, any> = {}, LoaderTypes extends WithDefaultTypes<Types> = WithDefaultTypes<Types>, Loaders extends DirectoryLoader = DirectoryLoader, Schema extends DirectorySchema | undefined = DirectorySchema | undefined, Filter extends DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined = DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined> = GitDirectoryOptions<Types, LoaderTypes, Loaders, Schema, Filter> | FileSystemDirectoryOptions<Types, LoaderTypes, Loaders, Schema, Filter>;
/** A directory containing files and subdirectories in the file system. */
export declare class Directory<Types extends Record<string, any> = {}, LoaderTypes extends WithDefaultTypes<Types> = WithDefaultTypes<Types>, Loaders extends DirectoryLoader = DirectoryLoader, Schema extends DirectorySchema | undefined = DirectorySchema | undefined, Filter extends DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined = DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined> {
    #private;
    constructor(options?: GitDirectoryOptions<Types, LoaderTypes, Loaders, Schema, Filter>);
    constructor(options: FileSystemDirectoryOptions<Types, LoaderTypes, Loaders, Schema, Filter>);
    /** Returns the glob filter pattern kind for this directory if defined. */
    getFilterPatternKind(): 'recursive' | 'shallow' | null;
    /** Returns whether this directory uses a predicate filter. */
    hasPredicateFilter(): boolean;
    /** Get the schema configuration for this directory. */
    getSchema(): DirectorySchema | undefined;
    /** Get the file system for this directory. */
    getFileSystem(): FileSystem;
    /** Get the `Repository` for this directory. */
    getRepository(repository?: RepositoryInput): Repository;
    /** Get the depth of the directory starting from the root directory. */
    get depth(): number;
    /**
     * Get a file at the specified `path` in the file system. The `path` does not
     * need to include the order prefix or extension. Additionally, an `extension`
     * can be provided for the second argument to find the first matching file path
     * that includes the extension.
     *
     * If the file is not found, an error will be thrown. Use `FileNotFoundError`
     * to handle the error.
     */
    getFile<const Path extends string, Extension extends ExtractFileExtension<Path> = ExtractFileExtension<Path>>(path: Path): Promise<Extension extends string ? IsJavaScriptLikeExtension<Extension> extends true ? JavaScriptFile<JavaScriptFileExtensionTypes<Extension, ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>>, any, string, Extension> : Extension extends 'mdx' ? MDXFile<WithUnknownExportsIfNoConcreteSchema<Schema, ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>['mdx']>, any, string, Extension> : Extension extends 'md' ? MarkdownFile<WithUnknownExportsIfNoConcreteSchema<Schema, ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>['md']>, any, string, Extension> : Extension extends 'json' ? JSONFile<JSONExtensionType<ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>> & Record<string, any>, any, string, Extension> : File<any, Path, Extension> : File<any>>;
    getFile<const Extension extends keyof ResolveDirectoryTypes<LoaderTypes, Loaders, Schema> & string>(path: string | string[], extension: Extension): Promise<IsJavaScriptLikeExtension<Extension> extends true ? JavaScriptFile<JavaScriptFileExtensionTypes<Extension, ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>>, any, string, Extension> : Extension extends 'mdx' ? MDXFile<WithUnknownExportsIfNoConcreteSchema<Schema, ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>['mdx']>, any, string, Extension> : Extension extends 'md' ? MarkdownFile<WithUnknownExportsIfNoConcreteSchema<Schema, ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>['md']>, any, string, Extension> : Extension extends 'json' ? JSONFile<JSONExtensionType<ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>> & Record<string, any>, any, string, Extension> : File<any, Extension>>;
    getFile<const Extension extends string | readonly string[]>(path: string | string[], extension?: Extension): Promise<ExtensionElement<Extension> extends infer Ext extends string ? IsJavaScriptLikeExtension<Ext> extends true ? JavaScriptFile<JavaScriptFileExtensionTypes<Ext, ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>>, any, string, Ext> : Ext extends 'mdx' ? MDXFile<WithUnknownExportsIfNoConcreteSchema<Schema, ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>['mdx']>, any, string, Ext> : Ext extends 'md' ? MarkdownFile<WithUnknownExportsIfNoConcreteSchema<Schema, ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>['md']>, any, string, Ext> : Ext extends 'json' ? JSONFile<JSONExtensionType<ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>> & Record<string, any>, any, string, Ext> : File<any, Ext> : File<any>>;
    /** Get a directory at the specified `path`. */
    getDirectory(path: string | string[]): Promise<Directory<LoaderTypes>>;
    /**
     * Get a directory or file at the specified `path`.
     *
     * - If a directory exists at the `path` and it contains a file with the same
     *   base name as the directory (e.g. `Button/Button.tsx`), that file is returned.
     * - Otherwise, the directory itself is returned when it exists.
     * - If no directory exists, a file at the `path` is resolved.
     *
     * ```ts
     * import { Directory } from 'renoun'
     *
     * // Same‑named file inside directory
     * // components/Button/Button.tsx
     * await new Directory({ path: 'components' }).getEntry('button') // JavaScriptFile
     *
     * // Directory has only index/readme (no same‑named file)
     * // components/CodeBlock/index.tsx
     * await new Directory({ path: 'components' }).getEntry('code-block') // JavaScriptFile
     *
     * // No directory at path, only a file
     * // components/Card.tsx
     * await new Directory({ path: 'components' }).getEntry('card') // JavaScriptFile
     *
     * // Nested lookup within an existing directory
     * // src/analysis/server.ts
     * const project = await new Directory({ path: 'src' }).getDirectory('project')
     * await project.getEntry('server') // JavaScriptFile
     *
     * // Finally, if no file is found, the directory is returned
     * // src/analysis/index.tsx
     * await new Directory({ path: 'src' }).getEntry('project') // Directory
     * ```
     */
    getEntry(path: string | string[]): Promise<FileSystemEntry<LoaderTypes>>;
    invalidateSnapshots(path?: string): void;
    /**
     * Retrieves all entries (files and directories) within the current directory
     * that are not excluded by Git ignore rules or the closest `tsconfig` file.
     * Additionally, `index` and `readme` files are excluded by default.
     */
    getEntries<const ProvidedFilter extends DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>, ApplyDirectorySchema<LoaderTypes, Schema>> | undefined = Filter>(options?: DirectoryFlatEntriesOptions<ProvidedFilter extends undefined ? Filter : ProvidedFilter>): Promise<Array<ResolveDirectoryFilterEntries<ProvidedFilter extends undefined ? Filter : ProvidedFilter, ApplyDirectorySchema<LoaderTypes, Schema>>>>;
    getTree(options?: {
        includeIndexAndReadmeFiles?: boolean;
    }): Promise<NavigationEntry<FileSystemEntry<ApplyDirectorySchema<LoaderTypes, Schema>>>[]>;
    getStructure(options?: StructureOptions): Promise<Array<DirectoryStructure | FileStructure>>;
    /** Get the root directory path. */
    getRootPath(): string;
    /** Get the parent directory containing this directory. */
    getParent(): Directory<any, any, any, DirectorySchema | undefined, DirectoryFilter<FileSystemEntry<ApplyDirectorySchema<any, DirectorySchema | undefined>, undefined>, ApplyDirectorySchema<any, DirectorySchema | undefined>> | undefined>;
    /** Get the previous and next sibling entries (files or directories) of the parent directory. */
    getSiblings<GroupTypes extends Record<string, any> = LoaderTypes>(options?: {
        collection?: Collection<GroupTypes, FileSystemEntry<any>[]>;
    }): Promise<[
        FileSystemEntry<LoaderTypes> | undefined,
        FileSystemEntry<LoaderTypes> | undefined
    ]>;
    /** Get the slug of this directory. */
    get slug(): string;
    /** The directory name. */
    get name(): string;
    /** The base name of this directory. */
    get baseName(): string;
    /** The directory name formatted as a title. */
    get title(): string;
    /** Get a URL-friendly path to this directory. */
    getPathname(options?: {
        includeBasePathname?: boolean;
    }): string;
    /** Get the route path segments to this directory. */
    getPathnameSegments(options?: {
        includeBasePathname?: boolean;
    }): string[];
    /** The relative path of this directory to the root directory. */
    get relativePath(): string;
    /** The relative path of the directory to the workspace. */
    get workspacePath(): string;
    /** The absolute path of this directory. */
    get absolutePath(): string;
    /** Get the URL to the directory history for the configured git repository. */
    getHistoryUrl(options?: Pick<GetFileUrlOptions, 'ref'> & {
        repository?: RepositoryInput;
    }): string;
    /** Get the URL to the directory source for the configured git repository. */
    getSourceUrl(options?: Pick<GetFileUrlOptions, 'ref'> & {
        repository?: RepositoryInput;
    }): string;
    /** Get a release URL for the configured git repository. */
    getReleaseUrl(options?: SourceReleaseUrlOptions): Promise<string>;
    /** Retrieve metadata about a release for the configured git repository. */
    getRelease(options?: SourceReleaseOptions): Promise<Release>;
    /** Get the URI to the directory source code for the configured editor. */
    getEditorUri(options?: Pick<GetEditorUriOptions, 'editor'>): string;
    /** Get the first local git commit date of this directory. */
    getFirstCommitDate(): Promise<Date | undefined>;
    /** Get the last local git commit date of this directory. */
    getLastCommitDate(): Promise<Date | undefined>;
    /** Get the local git authors of this directory. */
    getAuthors(): Promise<import("./types.ts").GitAuthor[]>;
    /** Checks if this directory contains the provided entry. */
    hasEntry(entry: FileSystemEntry<any> | undefined): entry is FileSystemEntry<LoaderTypes>;
    /** Checks if this directory contains the provided file. */
    hasFile<ExtensionType extends keyof LoaderTypes | string, const Extension extends ExtensionType | Extension[]>(entry: FileSystemEntry<any> | undefined, extension?: Extension | Extension[]): entry is FileWithExtension<LoaderTypes, Extension>;
}
/** Converts a union type to an intersection type. */
type UnionToIntersection<Union> = (Union extends any ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection & Union : never;
/** Helper type to extract loader types from entries. */
type LoadersFromEntry<Entry> = Entry extends Directory<any, infer LoaderTypes, infer Loaders, infer Schema> ? LoaderTypes extends Record<string, any> ? Loaders extends DirectoryLoader ? Schema extends DirectorySchema | undefined ? {
    [Extension in keyof ResolveDirectoryTypes<LoaderTypes, Loaders, Schema> & string]: ModuleRuntimeLoader<ResolveDirectoryTypes<LoaderTypes, Loaders, Schema>[Extension]>;
} : {} : {} : {} : {};
type LoadersFromEntries<Entries extends FileSystemEntry<any>[]> = UnionToIntersection<LoadersFromEntry<Entries[number]>>;
type StripIndexSignature<Type> = {
    [Key in keyof Type as Key extends string ? string extends Key ? never : Key : Key extends number ? number extends Key ? never : Key : Key extends symbol ? symbol extends Key ? never : Key : never]: Type[Key];
};
type ResolveCollectionDirectoryTypes<LoaderTypes extends Record<string, any>, Loaders extends DirectoryLoader, Schema extends DirectorySchema | undefined> = ApplyDirectorySchema<MergeRecord<LoaderTypes, StripIndexSignature<InferDirectoryTypesFromLoaders<Loaders>>>, Schema>;
type CollectionTypesFromEntry<Entry> = Entry extends Directory<any, infer LoaderTypes, infer Loaders, infer Schema> ? LoaderTypes extends Record<string, any> ? Loaders extends DirectoryLoader ? Schema extends DirectorySchema | undefined ? ResolveCollectionDirectoryTypes<LoaderTypes, Loaders, Schema> : {} : {} : {} : Entry extends File<infer DirectoryTypes, any, any> ? StripIndexSignature<DirectoryTypes> : {};
type CollectionTypesFromEntries<Entries extends FileSystemEntry<any>[]> = UnionToIntersection<CollectionTypesFromEntry<Entries[number]>>;
type CollectionResolvedTypes<Types, Entries extends FileSystemEntry<any>[], Loaders extends ModuleLoaders> = [Types] extends [never] ? StripIndexSignature<MergeRecord<StripIndexSignature<InferModuleLoadersTypes<Loaders>>, CollectionTypesFromEntries<Entries>>> : StripIndexSignature<Extract<Types, Record<string, any>>>;
type CollectionLookupType<Types extends Record<string, any>, Extension extends string, Fallback> = Extract<Extension, keyof Types> extends infer Key ? [Key] extends [never] ? Fallback : Types[Key & keyof Types] : Fallback;
type CollectionModuleType<Types extends Record<string, any>, Extension extends string> = CollectionLookupType<Types, Extension, ModuleExports> extends infer Type ? Type extends Record<string, any> ? Type : ModuleExports : ModuleExports;
/** Options for a `Collection`. */
export interface CollectionOptions<Entries extends FileSystemEntry<any>[]> {
    entries: Entries;
}
/** A group of file system entries. */
export declare class Collection<Types extends Record<string, any> = never, const Entries extends FileSystemEntry<any>[] = FileSystemEntry<any>[], const Loaders extends ModuleLoaders = LoadersFromEntries<Entries>> {
    #private;
    constructor(options: CollectionOptions<Entries>);
    /** Get the root entries that define this collection. */
    getRootEntries(): readonly FileSystemEntry<any>[];
    /** Get all entries in the group. */
    getEntries(options?: {
        /** Include all entries in the group recursively. */
        recursive?: boolean;
        /** Include index and readme files in the group. */
        includeIndexAndReadmeFiles?: boolean;
    }): Promise<Entries>;
    getTree(options?: {
        includeIndexAndReadmeFiles?: boolean;
    }): Promise<NavigationEntry<FileSystemEntry<CollectionResolvedTypes<Types, Entries, Loaders>>>[]>;
    /** Get previous and next sibling entries for a pathname or entry in this collection. */
    getSiblingsFor(pathnameOrEntry: string | FileSystemEntry<CollectionResolvedTypes<Types, Entries, Loaders>>, options?: {
        includeIndexAndReadmeFiles?: boolean;
    }): Promise<[
        (FileSystemEntry<CollectionResolvedTypes<Types, Entries, Loaders>> | undefined),
        (FileSystemEntry<CollectionResolvedTypes<Types, Entries, Loaders>> | undefined)
    ]>;
    /** Get an entry in the group by its path. */
    getEntry(
    /** The path to the entry excluding leading numbers. */
    path: string | string[]): Promise<FileSystemEntry<CollectionResolvedTypes<Types, Entries, Loaders>>>;
    /** Get a file at the specified path and optional extension(s). */
    getFile<Path extends string | string[], const Extension extends string | undefined = undefined>(
    /**
     * The path to the entry excluding leading numbers. The final segment may
     * optionally include the file extension e.g. `"Button.mdx"`.
     */
    path: Path, 
    /** The extension or extensions to match. */
    extension?: Extension | Extension[]): Promise<Extension extends string ? IsJavaScriptLikeExtension<Extension> extends true ? JavaScriptFile<CollectionModuleType<CollectionResolvedTypes<Types, Entries, Loaders>, Extension>> : Extension extends 'mdx' ? MDXFile<CollectionModuleType<CollectionResolvedTypes<Types, Entries, Loaders>, 'mdx'>> : Extension extends 'md' ? MarkdownFile<CollectionModuleType<CollectionResolvedTypes<Types, Entries, Loaders>, 'md'>> : File<CollectionResolvedTypes<Types, Entries, Loaders>> : Path extends string ? ExtractFileExtension<Path> extends infer PathExtension extends string ? IsJavaScriptLikeExtension<PathExtension> extends true ? JavaScriptFile<CollectionModuleType<CollectionResolvedTypes<Types, Entries, Loaders>, PathExtension>> : PathExtension extends 'mdx' ? MDXFile<CollectionModuleType<CollectionResolvedTypes<Types, Entries, Loaders>, 'mdx'>> : PathExtension extends 'md' ? MarkdownFile<CollectionModuleType<CollectionResolvedTypes<Types, Entries, Loaders>, 'md'>> : File<CollectionResolvedTypes<Types, Entries, Loaders>> : File<CollectionResolvedTypes<Types, Entries, Loaders>> : File<CollectionResolvedTypes<Types, Entries, Loaders>>>;
    /** Get a directory at the specified path. */
    getDirectory(
    /** The path to the entry excluding leading numbers. */
    path: string | string[]): Promise<Directory<CollectionResolvedTypes<Types, Entries, Loaders>>>;
}
/** Determines if a `FileSystemEntry` is a `Directory`. */
export declare function isDirectory<Types extends Record<string, any>>(entry: FileSystemEntry<Types> | Collection<Types> | undefined): entry is Directory<Types>;
type JSONExtensionType<Types extends Record<string, any>> = 'json' extends keyof Types ? Types['json'] : JSONObject;
/** Determines the type of a `FileSystemEntry` based on its extension. */
export type FileWithExtension<Types extends Record<string, any>, Extension = LoadersToExtensions<Types>> = Extension extends string ? IsJavaScriptLikeExtension<Extension> extends true ? JavaScriptFile<Types[Extension], Types, any, Extension> : Extension extends 'mdx' ? MDXFile<Types['mdx'], Types, any, Extension> : Extension extends 'md' ? MarkdownFile<Types['md'], Types, any, Extension> : Extension extends 'json' ? JSONFile<JSONExtensionType<Types>, Types, any, Extension> : File<Types> : Extension extends string[] ? HasJavaScriptLikeExtensions<Extension> extends true ? JavaScriptFile<Types[Extension[number]], Types, any, Extension[number]> : Extension[number] extends 'mdx' ? MDXFile<Types['mdx'], Types, any, Extension[number]> : Extension[number] extends 'md' ? MarkdownFile<Types['md'], Types, any, Extension[number]> : Extension[number] extends 'json' ? JSONFile<JSONExtensionType<Types>, Types, any, Extension[number]> : File<Types> : File<Types>;
type StringUnion<Type> = Extract<Type, string> | (string & {});
/** Resolves valid extension patterns from an object of loaders. */
export type LoadersToExtensions<DirectoryLoaders extends ModuleLoaders, ExtensionUnion = StringUnion<keyof DirectoryLoaders>> = ExtensionUnion | ExtensionUnion[];
/**
 * Determines if a `FileSystemEntry` is a `File` and optionally narrows the
 * result based on the provided extensions.
 */
export declare function isFile<Types extends Record<string, any>, const Extension extends LoadersToExtensions<Types>>(entry: FileSystemEntry<Types> | undefined, extension?: Extension): entry is FileWithExtension<Types, Extension>;
/** Determines if a `FileSystemEntry` is a `JavaScriptFile`. */
export declare function isJavaScriptFile<FileTypes extends Record<string, any>, DirectoryTypes extends Record<string, any> = Record<string, any>>(entry: FileSystemEntry<DirectoryTypes> | undefined): entry is JavaScriptFile<FileTypes, DirectoryTypes>;
/** Determines if a `FileSystemEntry` is a `MarkdownFile`. */
export declare function isMarkdownFile<FileTypes extends Record<string, any>, DirectoryTypes extends Record<string, any> = Record<string, any>>(entry: FileSystemEntry<DirectoryTypes> | undefined): entry is MarkdownFile<FileTypes, DirectoryTypes>;
/** Determines if a `FileSystemEntry` is a `JSONFile`. */
export declare function isJSONFile<FileTypes extends Record<string, any>, DirectoryTypes extends Record<string, any> = Record<string, any>>(entry: FileSystemEntry<DirectoryTypes> | undefined): entry is JSONFile<FileTypes, DirectoryTypes>;
/** Determines if a `FileSystemEntry` is an `MDXFile`. */
export declare function isMDXFile<FileTypes extends Record<string, any>, DirectoryTypes extends Record<string, any> = Record<string, any>>(entry: FileSystemEntry<DirectoryTypes> | undefined): entry is MDXFile<FileTypes, DirectoryTypes>;
/**
 * Attempts to resolve a file from a `FileSystemEntry`, preferring `index` and
 * `readme` for directories. The result can be optionally narrowed by extension.
 */
export declare function resolveFileFromEntry<Types extends Record<string, any>, const Extension extends keyof Types & string = string>(entry: FileSystemEntry<Types>, extension?: Extension | readonly Extension[]): Promise<FileWithExtension<Types, Extension> | undefined>;
type ComparableValue = string | number | bigint | boolean | Date;
type IsPlainObject<Type> = Type extends object ? Type extends (...args: any) => any ? false : Type extends readonly any[] ? false : true : false;
type PreviousDepth = [never, 0, 1];
type NestedPropertyPath<Type, Prefix extends string = '', Depth extends number = 4> = [Depth] extends [never] ? never : {
    [Key in Extract<keyof Type, string>]: Type[Key] extends ComparableValue ? `${Prefix}${Key}` : IsPlainObject<Type[Key]> extends true ? NestedPropertyPath<Type[Key], `${Prefix}${Key}.`, PreviousDepth[Depth]> : never;
}[Extract<keyof Type, string>];
type ExtensionPropertyPaths<ExtensionTypes> = IsAny<ExtensionTypes> extends true ? never : {
    [Extension in keyof ExtensionTypes & string]: NestedPropertyPath<ExtensionTypes[Extension]>;
}[keyof ExtensionTypes & string];
type BuiltinProperty = 'name' | 'directory';
type ValidSortKey<ExtensionTypes> = LoadersWithRuntimeKeys<ExtensionTypes> extends never ? BuiltinProperty : [ExtensionPropertyPaths<ExtensionTypes>] extends [never] ? BuiltinProperty : string extends ExtensionPropertyPaths<ExtensionTypes> ? BuiltinProperty : BuiltinProperty | ExtensionPropertyPaths<ExtensionTypes>;
type Awaitable<Type> = Promise<Type> | Type;
type SortKeyExtractor<Entry extends FileSystemEntry<any>> = (entry: Entry) => Awaitable<ComparableValue>;
type SortDescriptorObject<ExtensionTypes extends Record<string, any>, Entry extends FileSystemEntry<ExtensionTypes>, Key extends ValidSortKey<ExtensionTypes> | SortKeyExtractor<Entry> = ValidSortKey<ExtensionTypes> | SortKeyExtractor<Entry>> = {
    readonly key: Key;
    readonly compare?: (a: ExtractComparable<Key>, b: ExtractComparable<Key>) => number;
    readonly direction?: 'ascending' | 'descending';
};
type EntryTypes<E> = E extends FileSystemEntry<infer T> ? T : never;
export type SortDescriptor<Entry extends FileSystemEntry<any>> = ValidSortKey<EntryTypes<Entry>> | SortKeyExtractor<Entry> | SortDescriptorObject<EntryTypes<Entry>, Entry>;
/** Compiles a set of sort descriptors into a sort function. */
export declare function sortEntries<ExtensionTypes extends Record<string, any>>(entries: FileSystemEntry<ExtensionTypes>[], descriptor: SortDescriptor<any>): Promise<void>;
type ExtractComparable<Key> = Key extends (...args: any) => Awaitable<infer Return> ? Awaited<Return> extends ComparableValue ? Awaited<Return> : ComparableValue : ComparableValue;
export declare function createSort<Entry extends FileSystemEntry<any>, Key extends SortKeyExtractor<Entry> = SortKeyExtractor<Entry>>(key: Key, compare?: (a: ExtractComparable<Key>, b: ExtractComparable<Key>) => number): SortDescriptorObject<any, Entry, Key>;