import { BatchValidationOptions } from 'fhir-runtime';
import { BatchValidationResult } from 'fhir-runtime';
import { buildNextLink } from 'fhir-persistence';
import { buildPaginationContext } from 'fhir-persistence';
import { buildSearchBundle } from 'fhir-persistence';
import { BuildSearchBundleOptions } from 'fhir-persistence';
import { buildSelfLink } from 'fhir-persistence';
import { buildSlicingDefinition } from 'fhir-runtime';
import { CachedExpansion } from 'fhir-persistence';
import { ChoiceTypeField } from 'fhir-runtime';
import { ChoiceValue } from 'fhir-runtime';
import { ConceptHierarchyEntry } from 'fhir-persistence';
import { ConceptHierarchyRepo } from 'fhir-persistence';
import { ConceptRow } from 'fhir-runtime';
import { DEFAULT_SEARCH_COUNT } from 'fhir-persistence';
import { DefinitionProvider } from 'fhir-definition';
import { DefinitionRegistry } from 'fhir-definition';
import { ElementIndexEntry } from 'fhir-persistence';
import { ElementIndexRepo } from 'fhir-persistence';
import { ElementIndexRow } from 'fhir-runtime';
import { evalFhirPath } from 'fhir-runtime';
import { evalFhirPathBoolean } from 'fhir-runtime';
import { evalFhirPathString } from 'fhir-runtime';
import { evalFhirPathTyped } from 'fhir-runtime';
import { executeSearch } from 'fhir-persistence';
import { ExpansionCacheRepo } from 'fhir-persistence';
import { extractChoiceTypeName } from 'fhir-runtime';
import { extractElementIndexRows } from 'fhir-runtime';
import { extractSDDependencies } from 'fhir-runtime';
import { extractSliceName } from 'fhir-runtime';
import { FhirPersistence } from 'fhir-persistence';
import { FhirRuntimeInstance } from 'fhir-runtime';
import type { FhirSystemReady } from 'fhir-persistence';
import { flattenConceptHierarchy } from 'fhir-runtime';
import { getSliceSiblings } from 'fhir-runtime';
import { hashToken } from 'fhir-persistence';
import { hasNextPage } from 'fhir-persistence';
import { hasSliceName } from 'fhir-runtime';
import { IGImportOrchestrator } from 'fhir-persistence';
import { IGImportResult } from 'fhir-persistence';
import { IGIndex } from 'fhir-persistence';
import { IGResourceMapEntry } from 'fhir-persistence';
import { IGResourceMapRepo } from 'fhir-persistence';
import { isBackboneElementType } from 'fhir-runtime';
import { isChoiceTypePath } from 'fhir-runtime';
import { makeExtensionSlicing } from 'fhir-runtime';
import { matchesChoiceType } from 'fhir-runtime';
import { MAX_SEARCH_COUNT } from 'fhir-persistence';
import { PaginationContext } from 'fhir-persistence';
import { parseSearchRequest } from 'fhir-persistence';
import { reindexAllV2 } from 'fhir-persistence';
import { reindexResourceTypeV2 } from 'fhir-persistence';
import { RepositoryError } from 'fhir-persistence';
import { ResourceGoneError } from 'fhir-persistence';
import { ResourceNotFoundError } from 'fhir-persistence';
import { ResourceVersionConflictError } from 'fhir-persistence';
import { SDIndexEntry } from 'fhir-persistence';
import { SDIndexRepo } from 'fhir-persistence';
import { SearchBundle } from 'fhir-persistence';
import { SearchBundleEntry } from 'fhir-persistence';
import { SearchOptions } from 'fhir-persistence';
import type { SearchParameterRegistry } from 'fhir-persistence';
import { SearchParamIndexRepo } from 'fhir-persistence';
import { SearchRequest } from 'fhir-persistence';
import { SearchResult } from 'fhir-persistence';
import { SlicingDefinition } from 'fhir-runtime';
import { SlicingDiscriminatorDef } from 'fhir-runtime';
import { SlicingRules } from 'fhir-runtime';
import { splitSearchValues } from 'fhir-persistence';
import { StorageAdapter } from 'fhir-persistence';
import type { StructureDefinitionRegistry } from 'fhir-persistence';
import { validateSlicingCompatibility } from 'fhir-runtime';

export { BatchValidationOptions }

export { BatchValidationResult }

export { buildNextLink }

export { buildPaginationContext }

export { buildSearchBundle }

export { BuildSearchBundleOptions }

export { buildSelfLink }

export { buildSlicingDefinition }

export { CachedExpansion }

export { ChoiceTypeField }

export { ChoiceValue }

export { ConceptHierarchyEntry }

export { ConceptHierarchyRepo }

export { ConceptRow }

/**
 * Create a StorageAdapter from the database configuration.
 *
 * Supported adapters:
 * - `sqlite`      → BetterSqlite3Adapter (native, Node.js / Electron)
 * - `sqlite-wasm` → removed in fhir-persistence v0.3.0; use `sqlite` instead
 * - `postgres`    → PostgresAdapter (pg connection pool)
 */
export declare function createAdapter(config: DatabaseConfig, logger: Logger): Promise<StorageAdapter>;

/**
 * Default console-based logger.
 */
export declare function createConsoleLogger(): Logger;

/**
 * Create and bootstrap a fully initialized FHIR engine.
 *
 * This is the single entry point for all FHIR applications.
 * It assembles fhir-definition, fhir-runtime, and fhir-persistence
 * into a running system from a single configuration object.
 *
 * @example
 * ```ts
 * const engine = await createFhirEngine({
 *   database: { type: 'sqlite', path: ':memory:' },
 *   packages: { path: './fhir-packages' },
 * });
 *
 * const patient = await engine.persistence.createResource('Patient', {
 *   resourceType: 'Patient',
 *   name: [{ family: 'Smith', given: ['John'] }],
 * });
 *
 * await engine.stop();
 * ```
 */
export declare function createFhirEngine(config?: FhirEngineConfig): Promise<FhirEngine>;

export declare type DatabaseConfig = SqliteDatabaseConfig | SqliteWasmDatabaseConfig | PostgresDatabaseConfig;

export { DEFAULT_SEARCH_COUNT }

/**
 * Type-safe config helper for `fhir.config.ts` / `fhir.config.js`.
 *
 * @example
 * ```ts
 * // fhir.config.ts
 * import { defineConfig } from 'fhir-engine';
 *
 * export default defineConfig({
 *   database: { type: 'sqlite', path: './fhir.db' },
 *   packages: { path: './fhir-packages' },
 * });
 * ```
 */
export declare function defineConfig(config: FhirEngineConfig): FhirEngineConfig;

export { DefinitionProvider }

export { DefinitionRegistry }

export { ElementIndexEntry }

export { ElementIndexRepo }

export { ElementIndexRow }

export declare interface EngineContext {
    /** The resolved engine configuration. */
    readonly config: FhirEngineConfig;
    /** DefinitionRegistry from fhir-definition (always available). */
    readonly definitions: DefinitionRegistry;
    /** FhirRuntimeInstance from fhir-runtime (always available). */
    readonly runtime: FhirRuntimeInstance;
    /** StorageAdapter from fhir-persistence (always available). */
    readonly adapter: StorageAdapter;
    /** FhirPersistence facade — undefined during init(), available from start() onward. */
    readonly persistence: FhirPersistence | undefined;
    /** Logger instance. */
    readonly logger: Logger;
}

export { evalFhirPath }

export { evalFhirPathBoolean }

export { evalFhirPathString }

export { evalFhirPathTyped }

export { executeSearch }

export { ExpansionCacheRepo }

export { extractChoiceTypeName }

export { extractElementIndexRows }

export { extractSDDependencies }

export { extractSliceName }

export declare interface FhirEngine {
    /** The loaded DefinitionRegistry from fhir-definition. */
    readonly definitions: DefinitionRegistry;
    /** The FhirRuntimeInstance from fhir-runtime. */
    readonly runtime: FhirRuntimeInstance;
    /** The StorageAdapter from fhir-persistence. */
    readonly adapter: StorageAdapter;
    /** The FhirPersistence facade (CRUD + Search + Indexing). */
    readonly persistence: FhirPersistence;
    /** StructureDefinition registry (populated from IG). */
    readonly sdRegistry: StructureDefinitionRegistry;
    /** SearchParameter registry (populated from IG). */
    readonly spRegistry: SearchParameterRegistry;
    /** IG initialization result. */
    readonly igResult: FhirSystemReady['igResult'];
    /** Resource types with database tables. */
    readonly resourceTypes: string[];
    /** Logger in use. */
    readonly logger: Logger;
    /** Shared context (same object plugins receive). */
    readonly context: EngineContext;
    /**
     * High-level FHIR search — parses query params, executes search, returns results.
     *
     * @param resourceType - The FHIR resource type (e.g. 'Patient').
     * @param queryParams - URL query parameters (e.g. `{ name: 'Smith', _count: '10' }`).
     * @param options - Optional search options (e.g. `{ total: 'accurate' }`).
     * @returns Search result with matched resources, includes, and optional total.
     */
    search(resourceType: string, queryParams: Record<string, string | string[] | undefined>, options?: SearchOptions): Promise<SearchResult>;
    /** Return engine health/status information. */
    status(): FhirEngineStatus;
    /** Gracefully shut down the engine (closes adapter). */
    stop(): Promise<void>;
}

export declare interface FhirEngineConfig {
    /** Database configuration. */
    database: DatabaseConfig;
    /** FHIR package loading configuration. */
    packages: PackagesConfig;
    /** IG list to resolve before loading (downloaded/linked into packages.path). */
    igs?: Array<{
        name: string;
        version?: string;
    }>;
    /** Package resolution options. */
    packageResolve?: {
        allowDownload?: boolean;
    };
    /** IG migration label (default: package.json name or 'fhir-engine.default'). */
    packageName?: string;
    /** IG migration version (default: package.json version or '1.0.0'). */
    packageVersion?: string;
    /** Logger instance (default: console-based logger). */
    logger?: Logger;
    /** Plugins to register (executed in registration order). */
    plugins?: FhirEnginePlugin[];
}

export declare interface FhirEnginePlugin {
    /** Unique plugin name (used in logs and error messages). */
    name: string;
    /** Called before FhirSystem.initialize(). ctx.persistence is undefined. */
    init?(ctx: EngineContext): Promise<void>;
    /** Called after FhirSystem.initialize(). ctx.persistence is available. */
    start?(ctx: EngineContext): Promise<void>;
    /** Called after all plugins have started. System is fully operational. */
    ready?(ctx: EngineContext): Promise<void>;
    /** Called on shutdown, in reverse registration order. */
    stop?(ctx: EngineContext): Promise<void>;
}

export declare interface FhirEngineStatus {
    /** FHIR versions loaded (e.g. ['4.0.1']). */
    fhirVersions: string[];
    /** Loaded package identifiers (e.g. ['hl7.fhir.r4.core@4.0.1']). */
    loadedPackages: string[];
    /** Resource types with database tables. */
    resourceTypes: string[];
    /** Database adapter type in use. */
    databaseType: 'sqlite' | 'sqlite-wasm' | 'postgres';
    /** IG migration action performed at startup. */
    igAction: 'new' | 'upgrade' | 'consistent';
    /** Timestamp when the engine finished bootstrapping. */
    startedAt: Date;
    /** Registered plugin names. */
    plugins: string[];
}

export { FhirPersistence }

export { FhirRuntimeInstance }

export { flattenConceptHierarchy }

export { getSliceSiblings }

export { hashToken }

export { hasNextPage }

export { hasSliceName }

export { IGImportOrchestrator }

export { IGImportResult }

export { IGIndex }

export { IGResourceMapEntry }

export { IGResourceMapRepo }

export { isBackboneElementType }

export { isChoiceTypePath }

/**
 * Load engine configuration from a file.
 *
 * If `configPath` is provided, loads that exact file.
 * Otherwise, searches the current working directory for config files
 * in this order: `fhir.config.ts` → `fhir.config.js` → `fhir.config.mjs` → `fhir.config.json`.
 *
 * Environment variable overrides are applied on top of the loaded config.
 *
 * @param configPath - Explicit path to a config file (optional).
 * @returns The resolved `FhirEngineConfig`.
 */
export declare function loadFhirConfig(configPath?: string): Promise<FhirEngineConfig>;

export declare interface Logger {
    debug(message: string, ...args: unknown[]): void;
    info(message: string, ...args: unknown[]): void;
    warn(message: string, ...args: unknown[]): void;
    error(message: string, ...args: unknown[]): void;
}

export { makeExtensionSlicing }

export { matchesChoiceType }

export { MAX_SEARCH_COUNT }

export declare interface PackagesConfig {
    /** Local directory containing FHIR packages (NPM tarballs or extracted). */
    path: string;
}

export { PaginationContext }

export { parseSearchRequest }

export declare interface PostgresDatabaseConfig {
    type: 'postgres';
    /** PostgreSQL connection string (e.g. 'postgresql://user:pass@localhost:5432/fhir_db'). */
    url: string;
    /** Maximum number of clients in the pool (default: 10). */
    max?: number;
    /** Idle timeout in milliseconds before a client is closed (default: 30000). */
    idleTimeoutMillis?: number;
    /** Connection timeout in milliseconds (default: 0 = no timeout). */
    connectionTimeoutMillis?: number;
}

export { reindexAllV2 }

export { reindexResourceTypeV2 }

export { RepositoryError }

export declare interface ResolvedPackage {
    /** Package name (e.g. 'hl7.fhir.r4.core'). */
    name: string;
    /** Resolved version. */
    version: string;
    /** Path in the project packages directory. */
    path: string;
    /** How the package was resolved. */
    source: 'cache' | 'download' | 'local';
}

/**
 * Resolve FHIR packages into a project's packages directory.
 *
 * Resolution order for each package:
 * 1. Already exists in packagesPath → use as-is (source: 'local')
 * 2. Found in system cache (~/.fhir/packages) → create symlink/junction (source: 'cache')
 * 3. Download from FHIR Package Registry → cache → create symlink (source: 'download')
 *
 * @param config  Engine configuration (uses config.igs and config.packages.path)
 * @param options Override packages list, target path, download policy, or logger
 * @returns       Result with resolved packages and any errors
 *
 * @example
 * ```ts
 * const result = await resolvePackages(config);
 * if (!result.success) {
 *   console.warn('Some packages failed:', result.errors);
 * }
 * ```
 */
export declare function resolvePackages(config: FhirEngineConfig, options?: ResolvePackagesOptions): Promise<ResolvePackagesResult>;

export declare interface ResolvePackagesOptions {
    /** Packages to resolve. Defaults to config.igs. */
    packages?: Array<{
        name: string;
        version?: string;
    }>;
    /** Target directory for resolved packages. Defaults to config.packages.path. */
    packagesPath?: string;
    /** Allow network downloads. Default: true. */
    allowDownload?: boolean;
    /** Logger instance. */
    logger?: Logger;
}

export declare interface ResolvePackagesResult {
    /** True if all packages resolved without errors. */
    success: boolean;
    /** Successfully resolved packages. */
    packages: ResolvedPackage[];
    /** Packages that failed to resolve. */
    errors: Array<{
        name: string;
        error: string;
    }>;
}

export { ResourceGoneError }

export { ResourceNotFoundError }

export { ResourceVersionConflictError }

export { SDIndexEntry }

export { SDIndexRepo }

export { SearchBundle }

export { SearchBundleEntry }

export { SearchOptions }

export { SearchParamIndexRepo }

export { SearchRequest }

export { SearchResult }

export { SlicingDefinition }

export { SlicingDiscriminatorDef }

export { SlicingRules }

export { splitSearchValues }

export declare interface SqliteDatabaseConfig {
    type: 'sqlite';
    /** File path or ':memory:' for in-memory database. */
    path: string;
    /** Enable WAL journal mode (default: true). */
    wal?: boolean;
    /** Busy timeout in milliseconds (default: 5000). */
    busyTimeout?: number;
}

export declare interface SqliteWasmDatabaseConfig {
    type: 'sqlite-wasm';
    /** File path or ':memory:'. */
    path: string;
}

export { StorageAdapter }

export { validateSlicingCompatibility }

export { }