import { z } from 'zod';
import { Node } from '@dbushell/xml-streamify';

declare const LexiconId: z.ZodString;
declare const LexicalEntryId: z.ZodString;
declare const SynsetId: z.ZodString;
declare const SenseId: z.ZodString;
declare const SyntacticBehaviorId: z.ZodString;
/** Note: only the literals that are found in the test wordnet xml file are listed */
declare const PartsOfSpeech$1: z.ZodUnion<readonly [z.ZodLiteral<"a">, z.ZodLiteral<"c">, z.ZodLiteral<"n">, z.ZodLiteral<"p">, z.ZodLiteral<"r">, z.ZodLiteral<"s">, z.ZodLiteral<"u">, z.ZodLiteral<"v">, z.ZodLiteral<"x">]>;
/** Note: only the literals that are found in the test wordnet xml file are listed */
declare const SenseRelationRelType$1: z.ZodUnion<readonly [z.ZodLiteral<"also">, z.ZodLiteral<"antonym">, z.ZodLiteral<"derivation">, z.ZodLiteral<"domain_member_region">, z.ZodLiteral<"domain_member_topic">, z.ZodLiteral<"domain_region">, z.ZodLiteral<"domain_topic">, z.ZodLiteral<"exemplifies">, z.ZodLiteral<"is_exemplified_by">, z.ZodLiteral<"other">, z.ZodLiteral<"participle">, z.ZodLiteral<"pertainym">, z.ZodLiteral<"similar">]>;
/** Note: only the literals that are found in the test wordnet xml file are listed */
declare const SynsetRelationRelType$2: z.ZodUnion<readonly [z.ZodLiteral<"also">, z.ZodLiteral<"attribute">, z.ZodLiteral<"cause">, z.ZodLiteral<"causes">, z.ZodLiteral<"domain_member_region">, z.ZodLiteral<"domain_member_topic">, z.ZodLiteral<"domain_region">, z.ZodLiteral<"domain_topic">, z.ZodLiteral<"entail">, z.ZodLiteral<"entails">, z.ZodLiteral<"exemplifies">, z.ZodLiteral<"has_domain_region">, z.ZodLiteral<"has_domain_topic">, z.ZodLiteral<"holo_member">, z.ZodLiteral<"holo_part">, z.ZodLiteral<"holo_substance">, z.ZodLiteral<"hypernym">, z.ZodLiteral<"hyponym">, z.ZodLiteral<"instance_hypernym">, z.ZodLiteral<"instance_hyponym">, z.ZodLiteral<"is_caused_by">, z.ZodLiteral<"is_entailed_by">, z.ZodLiteral<"is_exemplified_by">, z.ZodLiteral<"member_holonym">, z.ZodLiteral<"member_meronym">, z.ZodLiteral<"mero_member">, z.ZodLiteral<"mero_part">, z.ZodLiteral<"mero_substance">, z.ZodLiteral<"part_holonym">, z.ZodLiteral<"part_meronym">, z.ZodLiteral<"similar">, z.ZodLiteral<"substance_holonym">, z.ZodLiteral<"substance_meronym">]>;
declare const AdjPosition$1: z.ZodUnion<readonly [z.ZodLiteral<"a">, z.ZodLiteral<"ip">, z.ZodLiteral<"p">]>;
declare const Lemma: z.ZodObject<{
    writtenForm: z.ZodString;
    partOfSpeech: z.ZodUnion<readonly [z.ZodLiteral<"a">, z.ZodLiteral<"c">, z.ZodLiteral<"n">, z.ZodLiteral<"p">, z.ZodLiteral<"r">, z.ZodLiteral<"s">, z.ZodLiteral<"u">, z.ZodLiteral<"v">, z.ZodLiteral<"x">]>;
    pronunciations: z.ZodArray<z.ZodObject<{
        variety: z.ZodOptional<z.ZodString>;
        inner: z.ZodString;
    }, z.core.$strip>>;
}, z.core.$strip>;
type Lemma = z.infer<typeof Lemma>;
declare const LexicalEntry: z.ZodObject<{
    id: z.ZodString;
    lemmas: z.ZodArray<z.ZodObject<{
        writtenForm: z.ZodString;
        partOfSpeech: z.ZodUnion<readonly [z.ZodLiteral<"a">, z.ZodLiteral<"c">, z.ZodLiteral<"n">, z.ZodLiteral<"p">, z.ZodLiteral<"r">, z.ZodLiteral<"s">, z.ZodLiteral<"u">, z.ZodLiteral<"v">, z.ZodLiteral<"x">]>;
        pronunciations: z.ZodArray<z.ZodObject<{
            variety: z.ZodOptional<z.ZodString>;
            inner: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    senses: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        synset: z.ZodString;
        subCat: z.ZodOptional<z.ZodString>;
        adjPosition: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"a">, z.ZodLiteral<"ip">, z.ZodLiteral<"p">]>>;
        senseRelations: z.ZodArray<z.ZodObject<{
            relType: z.ZodUnion<readonly [z.ZodLiteral<"also">, z.ZodLiteral<"antonym">, z.ZodLiteral<"derivation">, z.ZodLiteral<"domain_member_region">, z.ZodLiteral<"domain_member_topic">, z.ZodLiteral<"domain_region">, z.ZodLiteral<"domain_topic">, z.ZodLiteral<"exemplifies">, z.ZodLiteral<"is_exemplified_by">, z.ZodLiteral<"other">, z.ZodLiteral<"participle">, z.ZodLiteral<"pertainym">, z.ZodLiteral<"similar">]>;
            dcType: z.ZodOptional<z.ZodString>;
            target: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    forms: z.ZodArray<z.ZodObject<{
        writtenForm: z.ZodString;
    }, z.core.$strip>>;
}, z.core.$strip>;
type LexicalEntry = z.infer<typeof LexicalEntry>;
declare const Sense: z.ZodObject<{
    id: z.ZodString;
    synset: z.ZodString;
    subCat: z.ZodOptional<z.ZodString>;
    adjPosition: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"a">, z.ZodLiteral<"ip">, z.ZodLiteral<"p">]>>;
    senseRelations: z.ZodArray<z.ZodObject<{
        relType: z.ZodUnion<readonly [z.ZodLiteral<"also">, z.ZodLiteral<"antonym">, z.ZodLiteral<"derivation">, z.ZodLiteral<"domain_member_region">, z.ZodLiteral<"domain_member_topic">, z.ZodLiteral<"domain_region">, z.ZodLiteral<"domain_topic">, z.ZodLiteral<"exemplifies">, z.ZodLiteral<"is_exemplified_by">, z.ZodLiteral<"other">, z.ZodLiteral<"participle">, z.ZodLiteral<"pertainym">, z.ZodLiteral<"similar">]>;
        dcType: z.ZodOptional<z.ZodString>;
        target: z.ZodString;
    }, z.core.$strip>>;
}, z.core.$strip>;
type Sense = z.infer<typeof Sense>;
declare const SenseRelation: z.ZodObject<{
    relType: z.ZodUnion<readonly [z.ZodLiteral<"also">, z.ZodLiteral<"antonym">, z.ZodLiteral<"derivation">, z.ZodLiteral<"domain_member_region">, z.ZodLiteral<"domain_member_topic">, z.ZodLiteral<"domain_region">, z.ZodLiteral<"domain_topic">, z.ZodLiteral<"exemplifies">, z.ZodLiteral<"is_exemplified_by">, z.ZodLiteral<"other">, z.ZodLiteral<"participle">, z.ZodLiteral<"pertainym">, z.ZodLiteral<"similar">]>;
    dcType: z.ZodOptional<z.ZodString>;
    target: z.ZodString;
}, z.core.$strip>;
type SenseRelation = z.infer<typeof SenseRelation>;
declare const Pronunciation: z.ZodObject<{
    variety: z.ZodOptional<z.ZodString>;
    inner: z.ZodString;
}, z.core.$strip>;
type Pronunciation = z.infer<typeof Pronunciation>;
declare const Form: z.ZodObject<{
    writtenForm: z.ZodString;
}, z.core.$strip>;
type Form = z.infer<typeof Form>;
declare const Synset: z.ZodObject<{
    id: z.ZodString;
    ili: z.ZodString;
    members: z.ZodArray<z.ZodString>;
    partOfSpeech: z.ZodUnion<readonly [z.ZodLiteral<"a">, z.ZodLiteral<"c">, z.ZodLiteral<"n">, z.ZodLiteral<"p">, z.ZodLiteral<"r">, z.ZodLiteral<"s">, z.ZodLiteral<"u">, z.ZodLiteral<"v">, z.ZodLiteral<"x">]>;
    lexfile: z.ZodString;
    dcSource: z.ZodOptional<z.ZodString>;
    definitions: z.ZodArray<z.ZodObject<{
        inner: z.ZodString;
    }, z.core.$strip>>;
    examples: z.ZodArray<z.ZodObject<{
        inner: z.ZodString;
        dcSource: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    iliDefinitions: z.ZodArray<z.ZodObject<{
        inner: z.ZodString;
    }, z.core.$strip>>;
    synsetRelations: z.ZodArray<z.ZodObject<{
        relType: z.ZodUnion<readonly [z.ZodLiteral<"also">, z.ZodLiteral<"attribute">, z.ZodLiteral<"cause">, z.ZodLiteral<"causes">, z.ZodLiteral<"domain_member_region">, z.ZodLiteral<"domain_member_topic">, z.ZodLiteral<"domain_region">, z.ZodLiteral<"domain_topic">, z.ZodLiteral<"entail">, z.ZodLiteral<"entails">, z.ZodLiteral<"exemplifies">, z.ZodLiteral<"has_domain_region">, z.ZodLiteral<"has_domain_topic">, z.ZodLiteral<"holo_member">, z.ZodLiteral<"holo_part">, z.ZodLiteral<"holo_substance">, z.ZodLiteral<"hypernym">, z.ZodLiteral<"hyponym">, z.ZodLiteral<"instance_hypernym">, z.ZodLiteral<"instance_hyponym">, z.ZodLiteral<"is_caused_by">, z.ZodLiteral<"is_entailed_by">, z.ZodLiteral<"is_exemplified_by">, z.ZodLiteral<"member_holonym">, z.ZodLiteral<"member_meronym">, z.ZodLiteral<"mero_member">, z.ZodLiteral<"mero_part">, z.ZodLiteral<"mero_substance">, z.ZodLiteral<"part_holonym">, z.ZodLiteral<"part_meronym">, z.ZodLiteral<"similar">, z.ZodLiteral<"substance_holonym">, z.ZodLiteral<"substance_meronym">]>;
        target: z.ZodString;
    }, z.core.$strip>>;
}, z.core.$strip>;
type Synset = z.infer<typeof Synset>;
declare const Definition: z.ZodObject<{
    inner: z.ZodString;
}, z.core.$strip>;
type Definition = z.infer<typeof Definition>;
declare const Example: z.ZodObject<{
    inner: z.ZodString;
    dcSource: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type Example = z.infer<typeof Example>;
declare const ILIDefinition: z.ZodObject<{
    inner: z.ZodString;
}, z.core.$strip>;
type ILIDefinition = z.infer<typeof ILIDefinition>;
declare const SynsetRelation: z.ZodObject<{
    relType: z.ZodUnion<readonly [z.ZodLiteral<"also">, z.ZodLiteral<"attribute">, z.ZodLiteral<"cause">, z.ZodLiteral<"causes">, z.ZodLiteral<"domain_member_region">, z.ZodLiteral<"domain_member_topic">, z.ZodLiteral<"domain_region">, z.ZodLiteral<"domain_topic">, z.ZodLiteral<"entail">, z.ZodLiteral<"entails">, z.ZodLiteral<"exemplifies">, z.ZodLiteral<"has_domain_region">, z.ZodLiteral<"has_domain_topic">, z.ZodLiteral<"holo_member">, z.ZodLiteral<"holo_part">, z.ZodLiteral<"holo_substance">, z.ZodLiteral<"hypernym">, z.ZodLiteral<"hyponym">, z.ZodLiteral<"instance_hypernym">, z.ZodLiteral<"instance_hyponym">, z.ZodLiteral<"is_caused_by">, z.ZodLiteral<"is_entailed_by">, z.ZodLiteral<"is_exemplified_by">, z.ZodLiteral<"member_holonym">, z.ZodLiteral<"member_meronym">, z.ZodLiteral<"mero_member">, z.ZodLiteral<"mero_part">, z.ZodLiteral<"mero_substance">, z.ZodLiteral<"part_holonym">, z.ZodLiteral<"part_meronym">, z.ZodLiteral<"similar">, z.ZodLiteral<"substance_holonym">, z.ZodLiteral<"substance_meronym">]>;
    target: z.ZodString;
}, z.core.$strip>;
type SynsetRelation = z.infer<typeof SynsetRelation>;
declare const SyntacticBehavior: z.ZodObject<{
    id: z.ZodString;
    subcategorizationFrame: z.ZodString;
}, z.core.$strip>;
type SyntacticBehavior = z.infer<typeof SyntacticBehavior>;
declare const Lexicon: z.ZodObject<{
    id: z.ZodString;
    label: z.ZodString;
    language: z.ZodString;
    email: z.ZodString;
    license: z.ZodString;
    version: z.ZodString;
    url: z.ZodString;
    citation: z.ZodOptional<z.ZodString>;
    lexicalEntries: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        lemmas: z.ZodArray<z.ZodObject<{
            writtenForm: z.ZodString;
            partOfSpeech: z.ZodUnion<readonly [z.ZodLiteral<"a">, z.ZodLiteral<"c">, z.ZodLiteral<"n">, z.ZodLiteral<"p">, z.ZodLiteral<"r">, z.ZodLiteral<"s">, z.ZodLiteral<"u">, z.ZodLiteral<"v">, z.ZodLiteral<"x">]>;
            pronunciations: z.ZodArray<z.ZodObject<{
                variety: z.ZodOptional<z.ZodString>;
                inner: z.ZodString;
            }, z.core.$strip>>;
        }, z.core.$strip>>;
        senses: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            synset: z.ZodString;
            subCat: z.ZodOptional<z.ZodString>;
            adjPosition: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"a">, z.ZodLiteral<"ip">, z.ZodLiteral<"p">]>>;
            senseRelations: z.ZodArray<z.ZodObject<{
                relType: z.ZodUnion<readonly [z.ZodLiteral<"also">, z.ZodLiteral<"antonym">, z.ZodLiteral<"derivation">, z.ZodLiteral<"domain_member_region">, z.ZodLiteral<"domain_member_topic">, z.ZodLiteral<"domain_region">, z.ZodLiteral<"domain_topic">, z.ZodLiteral<"exemplifies">, z.ZodLiteral<"is_exemplified_by">, z.ZodLiteral<"other">, z.ZodLiteral<"participle">, z.ZodLiteral<"pertainym">, z.ZodLiteral<"similar">]>;
                dcType: z.ZodOptional<z.ZodString>;
                target: z.ZodString;
            }, z.core.$strip>>;
        }, z.core.$strip>>;
        forms: z.ZodArray<z.ZodObject<{
            writtenForm: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    synsets: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        ili: z.ZodString;
        members: z.ZodArray<z.ZodString>;
        partOfSpeech: z.ZodUnion<readonly [z.ZodLiteral<"a">, z.ZodLiteral<"c">, z.ZodLiteral<"n">, z.ZodLiteral<"p">, z.ZodLiteral<"r">, z.ZodLiteral<"s">, z.ZodLiteral<"u">, z.ZodLiteral<"v">, z.ZodLiteral<"x">]>;
        lexfile: z.ZodString;
        dcSource: z.ZodOptional<z.ZodString>;
        definitions: z.ZodArray<z.ZodObject<{
            inner: z.ZodString;
        }, z.core.$strip>>;
        examples: z.ZodArray<z.ZodObject<{
            inner: z.ZodString;
            dcSource: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        iliDefinitions: z.ZodArray<z.ZodObject<{
            inner: z.ZodString;
        }, z.core.$strip>>;
        synsetRelations: z.ZodArray<z.ZodObject<{
            relType: z.ZodUnion<readonly [z.ZodLiteral<"also">, z.ZodLiteral<"attribute">, z.ZodLiteral<"cause">, z.ZodLiteral<"causes">, z.ZodLiteral<"domain_member_region">, z.ZodLiteral<"domain_member_topic">, z.ZodLiteral<"domain_region">, z.ZodLiteral<"domain_topic">, z.ZodLiteral<"entail">, z.ZodLiteral<"entails">, z.ZodLiteral<"exemplifies">, z.ZodLiteral<"has_domain_region">, z.ZodLiteral<"has_domain_topic">, z.ZodLiteral<"holo_member">, z.ZodLiteral<"holo_part">, z.ZodLiteral<"holo_substance">, z.ZodLiteral<"hypernym">, z.ZodLiteral<"hyponym">, z.ZodLiteral<"instance_hypernym">, z.ZodLiteral<"instance_hyponym">, z.ZodLiteral<"is_caused_by">, z.ZodLiteral<"is_entailed_by">, z.ZodLiteral<"is_exemplified_by">, z.ZodLiteral<"member_holonym">, z.ZodLiteral<"member_meronym">, z.ZodLiteral<"mero_member">, z.ZodLiteral<"mero_part">, z.ZodLiteral<"mero_substance">, z.ZodLiteral<"part_holonym">, z.ZodLiteral<"part_meronym">, z.ZodLiteral<"similar">, z.ZodLiteral<"substance_holonym">, z.ZodLiteral<"substance_meronym">]>;
            target: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    syntacticBehaviors: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        subcategorizationFrame: z.ZodString;
    }, z.core.$strip>>;
}, z.core.$strip>;
type Lexicon = z.infer<typeof Lexicon>;
declare const partsOfSpeechList: string[];

/**
 * SQLite schema for WordNet export.
 * Also available as dist/schema.sql in the package.
 */
declare const SCHEMA = "\nCREATE TABLE IF NOT EXISTS words (\n  id INTEGER PRIMARY KEY,\n  word TEXT NOT NULL,          -- lowercase for search\n  word_display TEXT NOT NULL   -- original casing\n);\nCREATE INDEX IF NOT EXISTS idx_words_word ON words(word);\n\nCREATE TABLE IF NOT EXISTS synsets (\n  id TEXT PRIMARY KEY,\n  pos TEXT NOT NULL,\n  definition TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS word_synsets (\n  word_id INTEGER NOT NULL,\n  synset_id TEXT NOT NULL,\n  sense_order INTEGER NOT NULL DEFAULT 0,\n  PRIMARY KEY (word_id, synset_id)\n);\nCREATE INDEX IF NOT EXISTS idx_ws_word ON word_synsets(word_id);\nCREATE INDEX IF NOT EXISTS idx_ws_order ON word_synsets(word_id, sense_order);\n\nCREATE TABLE IF NOT EXISTS synset_relations (\n  source_id TEXT NOT NULL,\n  target_id TEXT NOT NULL,\n  rel_type TEXT NOT NULL,\n  PRIMARY KEY (source_id, target_id, rel_type)\n);\nCREATE INDEX IF NOT EXISTS idx_sr_source ON synset_relations(source_id);\nCREATE INDEX IF NOT EXISTS idx_sr_target ON synset_relations(target_id);\n\nCREATE TABLE IF NOT EXISTS sense_relations (\n  source_word_id INTEGER NOT NULL,\n  source_synset_id TEXT NOT NULL,\n  target_word_id INTEGER NOT NULL,\n  target_synset_id TEXT NOT NULL,\n  rel_type TEXT NOT NULL,\n  PRIMARY KEY (source_word_id, source_synset_id, target_word_id, target_synset_id, rel_type)\n);\nCREATE INDEX IF NOT EXISTS idx_sense_rel_source ON sense_relations(source_word_id, source_synset_id);\n\nCREATE TABLE IF NOT EXISTS synset_examples (\n  synset_id TEXT NOT NULL,\n  example TEXT NOT NULL,\n  example_order INTEGER NOT NULL DEFAULT 0,\n  PRIMARY KEY (synset_id, example_order)\n);\nCREATE INDEX IF NOT EXISTS idx_examples_synset ON synset_examples(synset_id);\n\nCREATE TABLE IF NOT EXISTS word_regions (\n  word_id INTEGER NOT NULL,\n  region  TEXT NOT NULL,\n  PRIMARY KEY (word_id, region)\n);\nCREATE INDEX IF NOT EXISTS idx_word_regions_region ON word_regions(region);\n";
interface ExportProgress {
    phase: "words" | "synsets" | "word_synsets" | "synset_examples" | "synset_relations" | "sense_relations" | "word_regions";
    current: number;
    total: number;
}
declare const ALL_TABLES: readonly ["words", "synsets", "word_synsets", "synset_relations", "sense_relations", "synset_examples", "word_regions"];
type ExportTable = (typeof ALL_TABLES)[number];
interface ExportOptions {
    onProgress?: (progress: ExportProgress) => void;
    /** If true, delete existing file before export. If false (default), error if file exists. */
    overwrite?: boolean;
    /**
     * Subset of tables to populate. When omitted, all tables are exported.
     * The schema (CREATE TABLE statements) is always run for every table; only
     * row insertion is gated. Validates that requested tables exist and that
     * each requested table's dependencies are also requested.
     */
    tables?: readonly ExportTable[];
}
/**
 * Export WordNet lexicon to SQLite database.
 * Creates a compact database optimized for word lookup and definition retrieval.
 */
declare function exportToSQLite(lexicon: Lexicon, outputPath: string, options?: ExportOptions): void;

/** LexiconNode is used as a root node for the whole WordNet document structure,
 * omitting the `LexicalResource` parent (and its virtual grandparent representing the
 * whole document). */
declare function LexiconNode(node: Node): Lexicon;
declare const decodeXmlEntities: (s: string | undefined) => string | undefined;

declare const PartsOfSpeech: Record<string, string>;
declare const SenseRelationRelType: Record<string, string>;
declare const SynsetRelationRelType$1: Record<string, string>;
declare const AdjPosition: Record<string, string>;

/** Base version to start searching from */
declare const BASE_VERSION = "2024";
/** Generate filename for a given version */
declare function getFilename(version: string): string;
/** Generate download URL for a given version */
declare function getDownloadUrl(version: string): string;
/** Default cache directory for downloaded WordNet data */
declare function getDefaultCacheDir(): string;
/**
 * Find the best available WordNet version.
 * - WordNet releases come out at END of year, so we only check up to (currentYear - 1)
 * - If cached version exists and no newer year has passed, use cache (no network)
 * - If a new year has passed since cache, check for that year's release
 * - If no cache, discover latest available
 */
declare function findLatestVersion(onProgress?: (message: string) => void, cacheDir?: string): Promise<string>;
/** Create XML streaming parser for WordNet file */
declare function createParser(filePath: string): AsyncGenerator<Node, void | Node, void>;
/** Parse Lexicon from XML stream */
declare function parseLexicon(parser: AsyncGenerator<Node, void | Node, void>): Promise<Lexicon | undefined>;
interface LoadOptions {
    /** Specific version to download (e.g., "2024"). If not set, finds latest. */
    version?: string;
    /** Custom cache directory for downloaded data */
    cacheDir?: string;
    /** Force re-download even if cached */
    forceDownload?: boolean;
    /** Callback for progress updates */
    onProgress?: (message: string) => void;
}
interface LoadResult {
    lexicon: Lexicon;
    version: string;
    filePath: string;
}
/**
 * Load WordNet from a local file path.
 * @param filePath Path to the WordNet XML file
 */
declare function loadWordNet(filePath: string): Promise<Lexicon>;
/**
 * Fetch WordNet from remote URL, cache locally, and parse.
 * If no version specified, finds the latest available version.
 * @param options Loading options
 * @returns LoadResult with lexicon, version, and file path
 */
declare function fetchWordNet(options?: LoadOptions): Promise<LoadResult>;
/**
 * Get path to cached WordNet file (downloads if not present).
 * Useful when you want to work with the file directly.
 * @returns Object with file path and version
 */
declare function ensureWordNetCached(options?: LoadOptions): Promise<{
    filePath: string;
    version: string;
}>;
declare const WORDNET_VERSION = "2024";
declare const WORDNET_FILENAME: string;
declare const WORDNET_URL: string;

type SynsetRelationRelType = z.infer<typeof SynsetRelationRelType$2>;
/** Definition with its source synset */
interface DefinitionResult {
    text: string;
    synset: Synset;
    partOfSpeech: string;
}
/** Synonym with its source context */
interface SynonymResult {
    word: string;
    entry: LexicalEntry;
    synset: Synset;
}
/** Indexed WordNet data for fast lookups */
interface WordNetIndex {
    /** All synsets indexed by ID */
    synsets: Map<string, Synset>;
    /** All senses indexed by ID */
    senses: Map<string, Sense>;
    /** All lexical entries indexed by ID */
    entries: Map<string, LexicalEntry>;
    /** Lexical entries indexed by word (lowercase) */
    byWord: Map<string, LexicalEntry[]>;
    /** Senses indexed by word (lowercase) */
    sensesByWord: Map<string, Sense[]>;
    /** Synsets indexed by word (lowercase) */
    synsetsByWord: Map<string, Synset[]>;
    /** Original lexicon */
    lexicon: Lexicon;
}
/**
 * Build an indexed structure for fast lookups.
 * Call this once after loading the lexicon.
 */
declare function buildIndex(lexicon: Lexicon): WordNetIndex;
/** Get a synset by ID */
declare function getSynset(index: WordNetIndex, id: string): Synset | undefined;
/** Get a sense by ID */
declare function getSense(index: WordNetIndex, id: string): Sense | undefined;
/** Get a lexical entry by ID */
declare function getLexicalEntry(index: WordNetIndex, id: string): LexicalEntry | undefined;
/** Find all lexical entries for a word */
declare function findWord(index: WordNetIndex, word: string): LexicalEntry[];
/** Find all senses for a word */
declare function findSenses(index: WordNetIndex, word: string): Sense[];
/** Find all synsets for a word */
declare function findSynsets(index: WordNetIndex, word: string): Synset[];
/** Get all definitions for a word */
declare function getDefinitions(index: WordNetIndex, word: string): DefinitionResult[];
/** Get related synsets by relation type */
declare function getRelated(index: WordNetIndex, synset: Synset, relType: SynsetRelationRelType): Synset[];
/** Get hypernyms (more general terms) for a word */
declare function getHypernyms(index: WordNetIndex, word: string): Synset[];
/** Get hyponyms (more specific terms) for a word */
declare function getHyponyms(index: WordNetIndex, word: string): Synset[];
/** Get synonyms for a word (words in the same synsets) */
declare function getSynonyms(index: WordNetIndex, word: string): SynonymResult[];
/** Get the written form of the first lemma for a synset */
declare function getSynsetWords(index: WordNetIndex, synset: Synset): string[];

export { AdjPosition$1 as AdjPosition, AdjPosition as AdjPositionLabels, BASE_VERSION, Definition, type DefinitionResult, Definition as DefinitionType, Example, Example as ExampleType, type ExportOptions, type ExportProgress, Form, Form as FormType, ILIDefinition, ILIDefinition as ILIDefinitionType, Lemma, Lemma as LemmaType, LexicalEntry, LexicalEntryId, LexicalEntry as LexicalEntryType, Lexicon, LexiconId, LexiconNode, Lexicon as LexiconType, type LoadOptions, type LoadResult, PartsOfSpeech$1 as PartsOfSpeech, PartsOfSpeech as PartsOfSpeechLabels, Pronunciation, Pronunciation as PronunciationType, SCHEMA, Sense, SenseId, SenseRelation, SenseRelationRelType as SenseRelationLabels, SenseRelationRelType$1 as SenseRelationRelType, SenseRelation as SenseRelationType, Sense as SenseType, type SynonymResult, Synset, SynsetId, SynsetRelation, SynsetRelationRelType$1 as SynsetRelationLabels, SynsetRelation as SynsetRelationObjectType, SynsetRelationRelType$2 as SynsetRelationRelType, Synset as SynsetType, SyntacticBehavior, SyntacticBehaviorId, SyntacticBehavior as SyntacticBehaviorType, WORDNET_FILENAME, WORDNET_URL, WORDNET_VERSION, type WordNetIndex, buildIndex, createParser, decodeXmlEntities, ensureWordNetCached, exportToSQLite, fetchWordNet, findLatestVersion, findSenses, findSynsets, findWord, getDefaultCacheDir, getDefinitions, getDownloadUrl, getFilename, getHypernyms, getHyponyms, getLexicalEntry, getRelated, getSense, getSynonyms, getSynset, getSynsetWords, loadWordNet, parseLexicon, partsOfSpeechList };