import { GlossaristModel } from '../models/base.js';
import type { Added as AddedType, Removed as RemovedType, Changed as ChangedType } from './change.js';
import { ListDiff } from './list-diff.js';
import type { Concept } from '../models/concept.js';
interface DiffStatsData {
    added?: number;
    removed?: number;
    changed?: number;
}
export declare class DiffStats extends GlossaristModel {
    private _added;
    private _removed;
    private _changed;
    constructor(data?: DiffStatsData);
    get added(): number;
    get removed(): number;
    get changed(): number;
    get total(): number;
    toJSON(): DiffStatsData;
    static fromJSON(data: DiffStatsData): DiffStats;
}
interface MetadataDiffData {
    changes?: Record<string, ChangedType | Record<string, unknown>>;
}
export declare class MetadataDiff extends GlossaristModel {
    private _changes;
    constructor(data?: MetadataDiffData);
    get changes(): Record<string, ChangedType>;
    get hasChanges(): boolean;
    get count(): number;
    walk(section?: string): Generator<{
        path: string;
        change: ChangedType;
    }>;
    toJSON(): Record<string, unknown>;
    static fromJSON(data: Record<string, unknown>): MetadataDiff;
}
interface ConceptLevelDiffData {
    sources?: ListDiff;
    dates?: ListDiff;
    relatedConcepts?: ListDiff;
    related_concepts?: ListDiff;
    relations?: ListDiff;
    partitiveRelations?: ListDiff;
    partitive_relations?: ListDiff;
    partitiveHyperedges?: ListDiff;
    partitive_hyperedges?: ListDiff;
    groups?: ListDiff;
    sections?: ListDiff;
    tags?: ListDiff;
    metadata?: MetadataDiff | Record<string, unknown>;
}
export declare class ConceptLevelDiff extends GlossaristModel {
    private _sources;
    private _dates;
    private _relatedConcepts;
    private _relations;
    private _groups;
    private _sections;
    private _tags;
    private _metadata;
    constructor(data?: ConceptLevelDiffData);
    get sources(): ListDiff;
    get dates(): ListDiff;
    get relatedConcepts(): ListDiff;
    get relations(): ListDiff;
    get partitiveRelations(): ListDiff;
    /** @deprecated use .relations */ get partitiveHyperedges(): ListDiff;
    get genericRelations(): ListDiff;
    get groups(): ListDiff;
    get sections(): ListDiff;
    get tags(): ListDiff;
    get metadata(): MetadataDiff;
    get hasChanges(): boolean;
    walk(): Generator<{
        path: string;
        change: AddedType | RemovedType | ChangedType;
    }>;
    toJSON(): Record<string, unknown>;
    static fromJSON(data: ConceptLevelDiffData): ConceptLevelDiff;
}
interface LocalizedConceptDiffData {
    languageCode?: string | null;
    language_code?: string | null;
    designations?: ListDiff;
    definitions?: ListDiff;
    notes?: ListDiff;
    examples?: ListDiff;
    sources?: ListDiff;
    dates?: ListDiff;
    related?: ListDiff;
    metadata?: MetadataDiff | Record<string, unknown>;
    totalItems?: number;
    total_items?: number;
}
export declare class LocalizedConceptDiff extends GlossaristModel {
    languageCode: string | null;
    private _designations;
    private _definitions;
    private _notes;
    private _examples;
    private _sources;
    private _dates;
    private _related;
    private _metadata;
    private _totalItems;
    private _statsCache?;
    private _similarityCache?;
    constructor(data?: LocalizedConceptDiffData);
    get designations(): ListDiff;
    get definitions(): ListDiff;
    get notes(): ListDiff;
    get examples(): ListDiff;
    get sources(): ListDiff;
    get dates(): ListDiff;
    get related(): ListDiff;
    get metadata(): MetadataDiff;
    get totalItems(): number;
    get hasChanges(): boolean;
    get stats(): DiffStats;
    get similarity(): number;
    walk(prefix?: string): Generator<{
        path: string;
        change: AddedType | RemovedType | ChangedType;
    }>;
    toJSON(): Record<string, unknown>;
    static fromJSON(data: LocalizedConceptDiffData): LocalizedConceptDiff;
}
interface ConceptDiffData {
    oldId?: string | null;
    old_id?: string | null;
    newId?: string | null;
    new_id?: string | null;
    concept?: ConceptLevelDiff | Record<string, unknown>;
    languages?: ListDiff;
    localizations?: Record<string, LocalizedConceptDiff | Record<string, unknown>>;
    totalItems?: number;
    total_items?: number;
}
export declare class ConceptDiff extends GlossaristModel {
    private _oldId;
    private _newId;
    private _concept;
    private _languages;
    private _localizations;
    private _totalItems;
    private _statsCache?;
    private _similarityCache?;
    constructor(data?: ConceptDiffData);
    get oldId(): string | null;
    get newId(): string | null;
    get concept(): ConceptLevelDiff;
    get languages(): ListDiff;
    get localizations(): Record<string, LocalizedConceptDiff>;
    get totalItems(): number;
    get localizationLanguages(): string[];
    get hasChanges(): boolean;
    localization(lang: string): LocalizedConceptDiff | null;
    get stats(): DiffStats;
    get similarity(): number;
    walk(): Generator<{
        path: string;
        change: AddedType | RemovedType | ChangedType;
        language?: string;
    }>;
    toJSON(): Record<string, unknown>;
    static fromJSON(data: ConceptDiffData): ConceptDiff;
}
export type ConceptLike = Concept | ({
    id?: string;
    languages?: readonly string[];
    localization(lang: string): unknown;
} & Record<string, unknown>) | null;
export declare function diffConcepts(oldConcept: ConceptLike, newConcept: ConceptLike, language?: string | null): ConceptDiff;
interface LocalizedConceptLike {
    languageCode?: string | null;
    terms?: readonly unknown[];
    definitions?: readonly unknown[];
    notes?: readonly unknown[];
    examples?: readonly unknown[];
    sources?: readonly unknown[];
    dates?: readonly unknown[];
    related?: readonly unknown[];
    [k: string]: unknown;
}
export declare function diffLocalizedConcepts(oldLoc: LocalizedConceptLike | null, newLoc: LocalizedConceptLike | null): LocalizedConceptDiff;
export {};
//# sourceMappingURL=concept-diff.d.ts.map