import type { ValidationResult, ValidationSettings } from '@records-fhir/validation-types';
import type { IReferenceValidator, ValidationContext, ValidationIssue } from '../types';
export declare class ReferenceValidator implements IReferenceValidator {
    private referenceTypeExtractor;
    private constraintValidator;
    private containedResolver;
    private bundleResolver;
    private circularDetector;
    private recursiveValidator;
    private versionValidator;
    private canonicalValidator;
    private batchedChecker;
    constructor();
    validate(resource: any, context: ValidationContext): Promise<ValidationResult>;
    validateInternal(resource: any, resourceType: string, fhirClientOrVersion?: any, // Can be FhirClient or FHIR version string
    fhirVersionOrSettings?: 'R4' | 'R5' | 'R6' | ValidationSettings, settings?: ValidationSettings): Promise<ValidationIssue[]>;
    private validateRecursiveReferences;
    private validateContainedReferences;
    extractResourceType(reference: string): string | null;
    parseReference(reference: string): import("./reference-type-extractor").ReferenceParseResult;
    validateReferenceTypeConstraint(reference: string, resourceType: string, fieldPath: string): import("./reference-type-constraint-validator").ReferenceTypeValidationResult;
    hasTypeConstraints(resourceType: string, fieldPath: string): boolean;
    getFieldConstraints(resourceType: string, fieldPath: string): import("./reference-type-constraint-validator").ReferenceTypeConstraint | null;
    resolveContainedReference(reference: string, parentResource: any, expectedType?: string): import("./contained-reference-resolver").ContainedReferenceResolutionResult;
    getContainedResources(resource: any): import("./contained-reference-resolver").ContainedResource[];
    validateContainedReferencesSync(resource: any): ValidationIssue[];
    resolveBundleReference(reference: string, bundle: any): import("./bundle-reference-types").BundleReferenceResolutionResult;
    validateBundleReferences(bundle: any): import("./bundle-reference-types").BundleIssue[];
    detectCircularReferences(resource: any, startingReferences?: string[]): import("./circular-reference-detector").CircularReferenceDetectionResult;
    wouldCreateCircularReference(currentPath: string[], newReference: string): boolean;
    getRecursiveValidationConfig(settings?: ValidationSettings): {
        enabled: boolean;
        maxDepth: number;
        validateExternal: boolean;
        validateContained: boolean;
        validateBundleEntries: boolean;
        excludeResourceTypes: string[] | undefined;
        maxReferencesPerResource: number;
        timeoutMs: number;
    };
    estimateRecursiveValidationCost(..._args: any[]): {
        estimatedResources: number;
        estimatedReferences: number;
        estimatedTimeMs: number;
        maxDepth: number;
        feasible: boolean;
    };
    validateRecursively(resource: any, config?: any, resourceFetcher?: (ref: string) => Promise<any>): Promise<import("./recursive-reference-validator").RecursiveValidationResult>;
    parseVersionedReference(reference: string): import("./version-specific-reference-types").VersionedReferenceInfo;
    validateVersionedReference(reference: string): import("./version-specific-reference-types").VersionIntegrityCheckResult;
    checkVersionConsistency(references: string[]): import("./version-specific-reference-types").VersionConsistencyCheckResult;
    extractVersionedReferences(resource: any): import("./version-specific-reference-types").VersionedReferenceInfo[];
    validateBundleVersionIntegrity(bundle: any): {
        isValid: boolean;
        issues: import("./version-specific-reference-types").VersionIntegrityCheckResult[];
        consistencyCheck: import("./version-specific-reference-types").VersionConsistencyCheckResult;
    };
    parseCanonicalUrl(canonical: string): import("./canonical-reference-validator").CanonicalReferenceInfo;
    validateCanonicalUrl(canonical: string): import("./canonical-reference-validator").CanonicalValidationResult;
    validateProfileCanonical(canonical: string): import("./canonical-reference-validator").CanonicalValidationResult;
    validateValueSetCanonical(canonical: string): import("./canonical-reference-validator").CanonicalValidationResult;
    extractCanonicalUrls(resource: any): import("./canonical-reference-validator").CanonicalReferenceInfo[];
    validateResourceCanonicals(resource: any): import("./canonical-reference-validator").CanonicalValidationResult[];
    validateBundleCanonicals(bundle: any): {
        isValid: boolean;
        results: import("./canonical-reference-validator").CanonicalValidationResult[];
        duplicateCanonicals?: Array<{
            canonical: string;
            count: number;
            entries: number[];
        }>;
    };
    checkBatchReferences(references: any[], config?: any): Promise<import("./batched-reference-checker").BatchCheckResult>;
    checkResourceReferences(resource: any, config?: any): Promise<import("./batched-reference-checker").BatchCheckResult>;
    checkBundleReferenceExistence(bundle: any, config?: any): Promise<import("./batched-reference-checker").BatchCheckResult>;
    filterExistingReferences(references: string[], config?: any): Promise<string[]>;
}
//# sourceMappingURL=reference-validator-refactored.d.ts.map