import { L as LanguagePack } from '../pack-u-LoPClV.cjs';

/**
 * Polish noun declension.
 *
 * Seven cases in two numbers is fourteen cells, but they are not fourteen
 * independent facts: the dative, instrumental and locative plural are
 * `-om`, `-ami`, `-ach` for every noun in the language, and the vocative
 * repeats the locative or the nominative. What is genuinely per-word is a
 * handful of choices — whether the masculine genitive is `-a` or `-u`,
 * whether the accusative copies the genitive, how the nominative plural is
 * formed — and those are what the generated lexicon stores.
 */
/** The cases Polish marks. */
type PlCase = "nominative" | "genitive" | "dative" | "accusative" | "instrumental" | "locative" | "vocative";
/**
 * The four declension patterns, named for what the nominative singular
 * looks like: `kobieta`, `okno`, `kot`, `noc`.
 */
type PlClass = "feminine-a" | "neuter" | "masculine" | "feminine-consonant";
/** What the lexicon can say about one noun. */
interface PlStemFlags {
    /** When the ending does not give the class away — `noc` is not a `kot`. */
    class?: PlClass;
    /** The oblique stem, when the rules cannot derive it from the nominative. */
    stem?: string;
    /** Masculine genitive singular: `-a` (kota) or `-u` (domu). */
    genSg?: string;
    /** Dative singular: `-owi` for most, `-u` for a short closed list. */
    datSg?: string;
    /** Locative singular, when neither `-e` nor `-u` follows from the stem. */
    locSg?: string;
    /** Nominative plural: `-y`, `-i`, `-e`, `-owie`, `-a`. */
    nomPl?: string;
    /** Genitive plural: `-ów`, `-y`, `-i`, or nothing at all. */
    genPl?: string;
    /** Animate: the accusative singular copies the genitive — `widzę kota`. */
    animate?: boolean;
    /** Personal (masculine): the accusative plural copies the genitive too. */
    personal?: boolean;
    /** Cells nothing shorter explains, keyed `case.number`. */
    forms?: Readonly<Record<string, string>>;
}
/** Guess the declension class from the nominative singular. */
declare function guessClass(lemma: string): PlClass;
/** Decline a Polish noun into one cell of its paradigm. */
declare function declineNoun(lemma: string, plCase: PlCase, plural: boolean, flags?: PlStemFlags): string;

/**
 * Polish adjective agreement.
 *
 * An adjective agrees with its noun in gender, number and case, which is
 * twenty-odd cells — but unlike the noun it is completely regular. Every
 * adjective in the language takes the same endings; the only variation is
 * whether the stem is hard (`czerwony`) or soft (`tani`), which decides
 * between `-y-` and `-i-` throughout.
 *
 * The one place meaning intrudes is the plural: a group that includes men
 * takes a separate set of endings, and the noun's own lexicon entry is what
 * knows that.
 */
/** The gender an adjective agrees with, derived from the noun's class. */
type PlGender = "masculine" | "feminine" | "neuter";
/** Build the agreeing form of an adjective. */
declare function agreeAdjective(word: string, gender: PlGender, plCase: PlCase, plural: boolean, options?: {
    personal?: boolean;
    animate?: boolean;
}): string;

/** The Polish language pack. */
declare const pl: LanguagePack;

export { agreeAdjective, declineNoun, guessClass, pl };