/**
 * Contained Reference Resolver
 *
 * Handles resolution and validation of contained resource references in FHIR resources.
 * Validates that contained references (#resource-id) exist and match type constraints.
 *
 * Task 6.3: Add support for contained resource reference validation
 */
export interface ContainedResource {
    /** Resource ID (without the # prefix) */
    id: string;
    /** Resource type */
    resourceType: string;
    /** The full contained resource */
    resource: any;
}
export interface ContainedReferenceResolutionResult {
    /** Whether the contained reference was found */
    found: boolean;
    /** The resolved contained resource if found */
    resource?: ContainedResource;
    /** Error message if not found */
    errorMessage?: string;
    /** The reference ID that was searched */
    referenceId: string;
    /** Whether the reference type matches (if type constraint specified) */
    typeMatches?: boolean;
    /** Expected type if constraint specified */
    expectedType?: string;
}
export interface ContainedReferenceValidationResult {
    /** Whether the contained reference is valid */
    isValid: boolean;
    /** Validation message */
    message: string;
    /** Severity level */
    severity: 'error' | 'warning' | 'info';
    /** Error code if invalid */
    code?: string;
    /** Resolution result */
    resolution?: ContainedReferenceResolutionResult;
}
export declare class ContainedReferenceResolver {
    /**
     * Extract all contained resources from a FHIR resource
     */
    extractContainedResources(resource: any): ContainedResource[];
    /**
     * Resolve a contained reference within a resource
     */
    resolveContainedReference(reference: string, parentResource: any, expectedType?: string): ContainedReferenceResolutionResult;
    /**
     * Validate a contained reference
     */
    validateContainedReference(reference: string, parentResource: any, expectedTypes?: string[]): ContainedReferenceValidationResult;
    /**
     * Validate all contained references in a resource
     */
    validateAllContainedReferences(resource: any, references: Array<{
        reference: string;
        fieldPath: string;
        expectedTypes?: string[];
    }>): Array<ContainedReferenceValidationResult & {
        fieldPath: string;
    }>;
    /**
     * Find all contained references in a resource
     */
    findContainedReferences(resource: any, fieldPath?: string): string[];
    /**
     * Get contained resource by ID
     */
    getContainedResourceById(parentResource: any, resourceId: string): ContainedResource | null;
    /**
     * Check if a resource has contained resources
     */
    hasContainedResources(resource: any): boolean;
    /**
     * Get all contained resource IDs
     */
    getContainedResourceIds(parentResource: any): string[];
    /**
     * Get all contained resources of a specific type
     */
    getContainedResourcesByType(parentResource: any, resourceType: string): ContainedResource[];
    /**
     * Validate that all contained resources are referenced
     */
    validateUnreferencedContainedResources(resource: any): {
        unreferencedResources: ContainedResource[];
        warnings: string[];
    };
    /**
     * Check for orphaned contained references (references that don't exist)
     */
    findOrphanedReferences(resource: any): Array<{
        reference: string;
        fieldPath?: string;
    }>;
}
export declare function getContainedReferenceResolver(): ContainedReferenceResolver;
export declare function resetContainedReferenceResolver(): void;
//# sourceMappingURL=contained-reference-resolver.d.ts.map