@scml-dol-maplebirch/types 5.0.4 → 5.1.1

package/modules/Frameworks/Patch.d.ts

@@ -0,0 +1,24 @@
+export type PatchPhase = 'init' | 'state';
+export interface PatchDefinition<T extends object = object, Flat extends object = T> {
+    api: T;
+    legacy?: Flat;
+    available?: () => boolean;
+    init?: () => void;
+    state?: () => void;
+}
+declare class Patch<Extensions extends Record<string, object> = Record<never, never>> {
+    private readonly report;
+    private readonly definitions;
+    constructor(report: (name: string, error: unknown) => void);
+    add<T extends object, Flat extends object = T>(name: string, definition: PatchDefinition<T, Flat>): this & Flat;
+    get<Name extends keyof Extensions>(name: Name): Extensions[Name] | undefined;
+    get<T extends object = object>(name: string): T | undefined;
+    require<Name extends keyof Extensions>(name: Name): Extensions[Name];
+    require<T extends object = object>(name: string): T;
+    has(name: string): boolean;
+    names(): string[];
+    private available;
+    private run;
+    apply(phase: PatchPhase): void;
+}
+export default Patch;

package/modules/Frameworks/RandSystem.d.ts

@@ -0,0 +1,27 @@
+import type { ScopedLog } from '../../infra/Diagnostics.js';
+export interface RandState {
+    seed: number | null;
+    history: number[];
+    index: number;
+}
+declare class randSystem {
+    static readonly log: ScopedLog;
+    static create(state?: Partial<RandState>): randSystem;
+    readonly log: ScopedLog;
+    readonly state: RandState;
+    private readonly maxHistory;
+    private readonly modulus;
+    constructor(state?: Partial<RandState>);
+    reset(seed?: number): void;
+    int(max: number): number;
+    percent(): number;
+    back(steps?: number): void;
+    forward(steps?: number): void;
+    get seed(): number | null;
+    set seed(value: number);
+    get history(): number[];
+    get index(): number;
+    private next;
+    private normalize;
+}
+export default randSystem;

package/modules/Frameworks/TextStore.d.ts

@@ -0,0 +1,7 @@
+type TextItem = string | number | boolean | null | undefined;
+declare class TextStore {
+    private readonly items;
+    push(...items: TextItem[]): void;
+    get play(): string;
+}
+export default TextStore;

package/modules/Frameworks/TimeTravelCheat.d.ts

@@ -0,0 +1,17 @@
+import type { MaplebirchCore } from '../../core.js';
+declare class TimeTravelCheat {
+    private readonly core;
+    private readonly ids;
+    constructor(core: MaplebirchCore);
+    fragment(): DocumentFragment;
+    private createRoot;
+    private bind;
+    private render;
+    private fieldInput;
+    private setFields;
+    private readFields;
+    private syncDayLimit;
+    private travel;
+    private status;
+}
+export default TimeTravelCheat;

package/modules/Frameworks/ZonesManager.d.ts

@@ -0,0 +1,69 @@
+import type { MaplebirchCore } from '../../core.js';
+import type { ScopedLog } from '../../infra/Diagnostics.js';
+import type AddonPlugin from '../../services/AddonPlugin.js';
+import { type SourcePatch } from '../../host/ModLoader.js';
+export interface ZoneWidgetConfig {
+    exclude?: string[];
+    match?: RegExp;
+    passage?: string | string[];
+    widget: string;
+    type?: 'function';
+    func?: () => unknown;
+}
+interface CustomLinkZoneItem {
+    position: number;
+    widget: string | ZoneWidgetConfig;
+}
+type PatchSet = SourcePatch;
+type ZoneItem = string | ZoneWidgetConfig | CustomLinkZoneItem;
+export type ZoneFunction = () => unknown;
+type InitObject = {
+    init: ZoneFunction;
+} | {
+    name: string;
+    func: ZoneFunction;
+};
+export type PositionedZoneWidgetConfig = Omit<ZoneWidgetConfig, 'widget'> & {
+    widget: [number, string];
+};
+export type ZoneWidget = string | ZoneFunction | ZoneWidgetConfig | PositionedZoneWidgetConfig | [number, string | ZoneWidgetConfig];
+export interface CustomLinkGroup {
+    position: number;
+    macro: string;
+}
+export type InitFunction = string | ZoneFunction | InitObject;
+export declare class zonesManager {
+    readonly log: ScopedLog;
+    readonly core: MaplebirchCore;
+    data: Record<string, ZoneItem[]>;
+    initFunction: InitFunction[];
+    specialWidget: (string | ZoneFunction)[];
+    defaultData: Record<string, string | ZoneFunction>;
+    locationPassage: Record<string, PatchSet[]>;
+    widgetPassage: Record<string, PatchSet[]>;
+    widgethtml: string;
+    private readonly functions;
+    private readonly functionNames;
+    private nextFunction;
+    constructor(core: MaplebirchCore);
+    inject(...databases: Partial<Pick<zonesManager, 'specialWidget' | 'defaultData' | 'locationPassage' | 'widgetPassage'>>[]): void;
+    onInit(...widgets: InitFunction[]): void;
+    addTo(zone: string, ...widgets: ZoneWidget[]): void;
+    storyInit(): void;
+    call(name: string): unknown;
+    play(zone: 'CustomLinkZone', passageTitle?: string): CustomLinkGroup[];
+    play(zone: 'State' | 'BeforeLinkZone' | 'AfterLinkZone', passageTitle?: string): string;
+    play(zone: string, passageTitle?: string): string | CustomLinkGroup[];
+    patchModToGame(manager: AddonPlugin, type: 'before' | 'after'): void;
+    private get widgets();
+    private get specials();
+    private defaultContent;
+    private render;
+    private shouldRender;
+    private customLinkItem;
+    private wrapSpecialPassage;
+    private applyContentPatches;
+    private patchPassage;
+    private widgetInit;
+}
+export {};

package/modules/Frameworks/macros.d.ts

@@ -0,0 +1,27 @@
+import type { MaplebirchCore } from '../../core.js';
+import type { ScopedLog } from '../../infra/Diagnostics.js';
+import type { MacroContext } from '../../macros/index.js';
+import type ToolCollection from '../ToolCollection.js';
+export type MacroFunction<Args extends unknown[] = unknown[]> = (this: MacroContext, ...args: Args) => unknown;
+export type SimpleMacroFunction<Args extends unknown[]> = (this: MacroContext | null, ...args: Args) => unknown;
+type StatFunction<Args extends unknown[] = unknown[]> = (...args: Args) => DocumentFragment;
+export type MacroTags = string[] | null | undefined;
+export type SkipArgs = string[] | boolean | null | undefined;
+export type MacroPhase = 'sugarcube' | 'storyready';
+declare class defineMacros {
+    readonly manager: ToolCollection;
+    readonly log: ScopedLog;
+    readonly macros: string[];
+    readonly statFunctions: Record<string, StatFunction>;
+    private readonly definitions;
+    private readonly ready;
+    constructor(manager: ToolCollection);
+    get Macro(): ReturnType<MaplebirchCore['host']['sugarcube']['require']>['Macro'];
+    define<Args extends unknown[]>(macroName: string, macroFunction: MacroFunction<Args>, tags?: MacroTags, skipArgs?: SkipArgs, isAsync?: boolean, phase?: MacroPhase): void;
+    private installAll;
+    private install;
+    defineS<Args extends unknown[]>(macroName: string, macroFunction: SimpleMacroFunction<Args>, tags?: MacroTags, skipArgs?: SkipArgs, maintainContext?: boolean, phase?: MacroPhase): void;
+    create<Args extends unknown[]>(name: string, fn: StatFunction<Args>): void;
+    callStatFunction(name: string, ...args: unknown[]): DocumentFragment;
+}
+export default defineMacros;

package/modules/Frameworks/migration.d.ts

@@ -0,0 +1,33 @@
+import type { ScopedLog } from '../../infra/Diagnostics.js';
+interface Step {
+    from: string;
+    to: string;
+    apply: (data: Record<string, unknown>, utils: Utils) => void;
+}
+interface PathRef {
+    parent: Record<string, unknown>;
+    key: string;
+}
+interface Utils {
+    readonly log: ScopedLog;
+    path: (obj: Record<string, unknown>, path: string, create?: boolean) => PathRef | null;
+    move: (data: Record<string, unknown>, from: string, to: string) => boolean;
+    remove: (data: Record<string, unknown>, path: string) => boolean;
+    transform: (data: Record<string, unknown>, path: string, fn: (value: unknown) => unknown) => boolean;
+    fill: (target: Record<string, unknown>, defaults: Record<string, unknown>, mode?: 'merge' | 'cover') => void;
+}
+declare class migration {
+    static readonly log: ScopedLog;
+    static create(): migration;
+    readonly log: ScopedLog;
+    readonly utils: Utils;
+    steps: Step[];
+    private readonly unsafeKeys;
+    constructor();
+    add(from: string, to: string, apply: Step['apply']): void;
+    run(data: Record<string, unknown>, targetVersion: string): void;
+    private path;
+    private move;
+    private compare;
+}
+export default migration;

package/modules/NamedNPC.d.ts

@@ -0,0 +1,164 @@
+import { MaplebirchCore } from '../core.js';
+import type { ScopedLog } from '../infra/Diagnostics.js';
+import type { Translation } from '../services/Translator.js';
+import NPCSchedules, { ScheduleConfig, ScheduleBuilder } from './NamedNPCAddon/NPCSchedules.js';
+import NPCClothes from './NamedNPCAddon/NPCClothes.js';
+import type { OutfitSetConfig } from './NamedNPCAddon/NPCClothes/NPCOutfitSets.js';
+import NPCSidebar from './NamedNPCAddon/NPCSidebar.js';
+import NPCFluids from './NamedNPCAddon/NPCFluids.js';
+import NPCTransformation from './NamedNPCAddon/NPCTransformation.js';
+import NPCPregnancy, { type NPCPregnancyState } from './NamedNPCAddon/NPCPregnancy.js';
+type PronounCode = 'm' | 'f' | 'i' | 'n' | 't';
+type TranslationInput = Map<string, Translation> | Record<string, Translation>;
+export interface NPCData {
+    nam: string;
+    gender?: 'm' | 'f' | 'h' | 'n' | 'none';
+    pronoun?: PronounCode;
+    title?: string;
+    description?: string;
+    type?: string;
+    adult?: number;
+    teen?: number;
+    age?: number;
+    insecurity?: string;
+    chastity?: {
+        penis: string;
+        vagina: string;
+        anus: string;
+    };
+    virginity?: Record<string, boolean>;
+    hair_side_type?: string;
+    hair_fringe_type?: string;
+    hair_position?: string;
+    hair_sides_length?: number;
+    hair_fringe_length?: number;
+    eyeColour?: string;
+    hairColour?: string;
+    bottomsize?: number;
+    skincolour?: number;
+    init?: number;
+    intro?: number;
+    penis?: string;
+    penissize?: number;
+    penisdesc?: string;
+    vagina?: string;
+    breastsize?: number;
+    breastdesc?: string;
+    ballssize?: number;
+    outfits?: string[];
+    pregnancy?: NPCPregnancyState | null;
+    pregnancyAvoidance?: number;
+    [key: string]: any;
+}
+export interface NPCConfig {
+    love?: {
+        maxValue: number;
+    };
+    loveAlias?: [string, string] | (() => string | [string, string]);
+    important?: boolean | (() => boolean);
+    special?: boolean | (() => boolean);
+    loveInterest?: boolean | (() => boolean);
+    romance?: (() => boolean)[];
+    [key: string]: unknown;
+}
+export interface NPCStatConfig {
+    min?: number;
+    max?: number;
+    default?: number;
+    position?: number | 'first' | 'last' | false;
+    [key: string]: unknown;
+}
+export declare const NamedNPC: {
+    new (manager: NPCManager, data: NPCData): {
+        nam: string;
+        gender: 'm' | 'f' | 'h' | 'n' | 'none';
+        title: string;
+        description: string;
+        type: string;
+        adult: number;
+        teen: number;
+        age: number;
+        insecurity: string;
+        chastity: {
+            penis: string;
+            vagina: string;
+            anus: string;
+        };
+        virginity: Record<string, boolean>;
+        hair_side_type: string;
+        hair_fringe_type: string;
+        hair_position: string;
+        hair_sides_length: number;
+        hair_fringe_length: number;
+        eyeColour: string;
+        hairColour: string;
+        pronoun: PronounCode;
+        pronouns: Record<string, string>;
+        bottomsize: number;
+        skincolour: number;
+        init: number;
+        intro: number;
+        penis: string;
+        penissize: number;
+        penisdesc: string;
+        vagina: string;
+        breastsize: number;
+        breastdesc: string;
+        breastsdesc: string;
+        bottomdesc: string;
+        ballsdesc: string;
+        ballssize: number;
+        outfits: string[];
+        pregnancy: NPCPregnancyState;
+        pregnancyAvoidance?: number;
+        descCache: Record<string, string>;
+        setPronouns(): void;
+        setBodyTraits(data: NPCData): void;
+        bodyPartdescription(): void;
+    };
+} & {
+    add: (manager: NPCManager, npcData: NPCData, config?: NPCConfig, translationsData?: TranslationInput) => boolean;
+    get: (manager: NPCManager) => string[];
+    clear: (manager: NPCManager) => boolean;
+    update: (manager: NPCManager) => boolean;
+    setup: (manager: NPCManager) => void;
+    proxy: (manager: NPCManager) => void;
+    convert: (manager: NPCManager) => void;
+};
+declare class NPCManager {
+    readonly core: MaplebirchCore;
+    readonly log: ScopedLog;
+    readonly data: Map<string, {
+        Data: InstanceType<typeof NamedNPC>;
+        Config: NPCConfig;
+    }>;
+    NPCNameList: string[];
+    readonly Transformation: NPCTransformation;
+    readonly Pregnancy: NPCPregnancy;
+    readonly type: Record<'loveInterestNpcs' | 'importantNPCs' | 'specialNPCs', string[]>;
+    readonly customStats: Record<string, NPCStatConfig>;
+    readonly romanceConditions: {
+        [key: string]: (() => boolean)[];
+    };
+    readonly NamedNPC: typeof NamedNPC;
+    readonly Schedule: typeof NPCSchedules;
+    readonly Clothes: NPCClothes;
+    readonly Sidebar: typeof NPCSidebar;
+    readonly fluids: NPCFluids;
+    constructor(core: MaplebirchCore);
+    add(npcData: NPCData, config?: NPCConfig, translationsData?: TranslationInput): boolean;
+    addSchedule(npcName: string, config: ScheduleConfig | ScheduleBuilder): import("./NamedNPCAddon/NPCSchedules.js").Schedule;
+    addStats(statsObject: Record<string, NPCStatConfig>): void;
+    addClothes(...configs: OutfitSetConfig[]): void;
+    injectModNPCs(): void;
+    vanillaNPCConfig(npcConfig: Record<string, NPCConfig>): Record<string, NPCConfig>;
+    applyStatDefaults(statDefaults: Record<string, NPCStatConfig>): Record<string, NPCStatConfig>;
+    vanillaInit(npcName: string): void;
+    vanillaInject(npcName: string, npcno: number): void;
+    private config;
+    preInit(): void;
+    Init(): void;
+    loadInit(): void;
+    postInit(): void;
+}
+export default NPCManager;

package/modules/NamedNPCAddon/NPCClothes/Condition.d.ts

@@ -0,0 +1,3 @@
+import type { MaplebirchCore } from '../../../core.js';
+export type Condition = boolean | string | (() => boolean) | Condition[];
+export declare function evaluate(core: MaplebirchCore, condition?: Condition): boolean;

package/modules/NamedNPCAddon/NPCClothes/NPCOutfitSets.d.ts

@@ -0,0 +1,38 @@
+import type NPCManager from '../../NamedNPC.js';
+interface OutfitPartConfig {
+    name: string;
+    integrity_max?: number;
+    word?: string;
+    action?: string;
+    readonly desc?: string;
+}
+export interface OutfitSetConfig {
+    name: string;
+    type?: string;
+    gender?: string;
+    outfit?: number;
+    upper: string | OutfitPartConfig;
+    lower: string | OutfitPartConfig;
+    desc?: string;
+}
+interface OutfitSet {
+    name: string;
+    type: string;
+    gender: string;
+    outfit: number;
+    clothes: {
+        upper: Required<OutfitPartConfig>;
+        lower: Required<OutfitPartConfig>;
+    };
+    desc: string;
+}
+declare class NPCOutfitSets {
+    private readonly manager;
+    constructor(manager: NPCManager);
+    init(): void;
+    add(...configs: OutfitSetConfig[]): void;
+    get data(): OutfitSet[];
+    private create;
+    private createPart;
+}
+export default NPCOutfitSets;

package/modules/NamedNPCAddon/NPCClothes/NPCSidebarArt.d.ts

@@ -0,0 +1,25 @@
+import type { ModZipReader } from '@scml/types/sugarcube-2-ModLoader/ModZipReader';
+import NPCManager from '../../NamedNPC.js';
+interface ResolvedArtLayer {
+    zIndex: number | string;
+    img: string;
+}
+type ArtPart = 'head' | 'face' | 'neck' | 'upper' | 'lower' | 'legs' | 'feet' | 'hands';
+export interface ResolvedArt {
+    key: string;
+    body: string;
+    parts: Partial<Record<ArtPart, ResolvedArtLayer>>;
+}
+declare class NPCSidebarArt {
+    private readonly manager;
+    private readonly configs;
+    constructor(manager: NPCManager);
+    import(modName: string, modZip: ModZipReader, filePaths: string | string[]): Promise<string[]>;
+    has(npcName: string, key: string): boolean;
+    keys(npcName: string): string[];
+    get(npcName: string, key: string): ResolvedArt | undefined;
+    get layers(): Map<string, Map<string, ResolvedArt>>;
+    private setConfig;
+    private resolve;
+}
+export default NPCSidebarArt;

package/modules/NamedNPCAddon/NPCClothes/NPCSidebarWardrobe.d.ts

@@ -0,0 +1,60 @@
+import { type Condition } from './Condition.js';
+import type NPCManager from '../../NamedNPC.js';
+import type { NPCClothesSlot, NPCSidebarClothing } from '../NPCSidebarConfig/types.js';
+type WardrobeClothing = Partial<NPCSidebarClothing>;
+type WardrobeItem = Partial<Record<NPCClothesSlot, WardrobeClothing>>;
+type WardrobeWetness = 'dry' | 'damp' | 'wet' | 'soaked';
+type WardrobeWetnessResolver = WardrobeWetness | (() => WardrobeWetness);
+interface WardrobeWearOptions {
+    when?: Condition;
+    wetness?: WardrobeWetnessResolver;
+}
+interface WardrobeConditionGroup {
+    location?: string | readonly string[];
+    passage?: string | readonly string[];
+    hours?: readonly [from: number, to: number];
+}
+type WardrobeWeightedChoice = readonly [key: string, weight: number];
+type WardrobeChoice = string | readonly WardrobeWeightedChoice[];
+type WardrobeLayerResolver = string | (() => string);
+interface WardrobeContext {
+    npcName: string;
+    location: string;
+    key: string;
+    wetness: WardrobeWetness;
+}
+type WardrobeModifier = (clothes: WardrobeItem, context: WardrobeContext) => void;
+declare class NPCSidebarWardrobe {
+    private readonly manager;
+    private readonly templates;
+    private readonly profiles;
+    private readonly conditions;
+    constructor(manager: NPCManager);
+    init(): void;
+    load(modName: string, filePath: string): Promise<void>;
+    get(key: string): WardrobeItem | undefined;
+    set(key: string, template: WardrobeItem): void;
+    has(key: string): boolean;
+    when(name: string, group?: WardrobeConditionGroup, condition?: Condition): () => boolean;
+    wear(npcName: string, location: string | readonly string[], choice: WardrobeChoice, options?: Condition | WardrobeWearOptions): void;
+    wet(npcName: string, wetness: WardrobeWetnessResolver, cond?: Condition): void;
+    layer(npcName: string, source: WardrobeLayerResolver, cond?: Condition): void;
+    apply(clothes: WardrobeItem, slot: NPCClothesSlot, item: WardrobeClothing): void;
+    put(clothes: WardrobeItem, key: string, slots?: NPCClothesSlot | readonly NPCClothesSlot[]): void;
+    strip(clothes: WardrobeItem, slot: NPCClothesSlot | readonly NPCClothesSlot[]): void;
+    base(npcName: string, modifier: WardrobeModifier): void;
+    modify(npcName: string, modifier: WardrobeModifier): void;
+    worn(npcName: string): WardrobeItem;
+    private run;
+    private add;
+    private merge;
+    private select;
+    private find;
+    private choose;
+    private findWet;
+    private resolveWet;
+    private applyWet;
+    private profile;
+    private location;
+}
+export default NPCSidebarWardrobe;

package/modules/NamedNPCAddon/NPCClothes.d.ts

@@ -0,0 +1,12 @@
+import type NPCManager from '../NamedNPC.js';
+import NPCOutfitSets from './NPCClothes/NPCOutfitSets.js';
+import NPCSidebarArt from './NPCClothes/NPCSidebarArt.js';
+import NPCSidebarWardrobe from './NPCClothes/NPCSidebarWardrobe.js';
+declare class NPCClothes {
+    readonly outfitSets: NPCOutfitSets;
+    readonly art: NPCSidebarArt;
+    readonly wardrobe: NPCSidebarWardrobe;
+    constructor(manager: NPCManager);
+    init(): void;
+}
+export default NPCClothes;

package/modules/NamedNPCAddon/NPCFluids.d.ts

@@ -0,0 +1,17 @@
+export type NPCFluidPart = 'vagina' | 'vaginaoutside' | 'anus' | 'mouth' | 'penis' | 'chest' | 'face' | 'hair' | 'bottom' | 'feet' | 'leftarm' | 'rightarm' | 'neck' | 'thigh' | 'tummy';
+export type NPCFluidType = 'goo' | 'semen';
+export type NPCFluidAmount = [goo: number, semen: number];
+export type NPCFluidData = Record<NPCFluidPart, NPCFluidAmount>;
+declare class NPCFluids {
+    readonly parts: NPCFluidPart[];
+    ensure(npcName: string): NPCFluidData;
+    get(npcName: string): NPCFluidData;
+    combined(npcName: string, part: NPCFluidPart): number;
+    set(npcName: string, part: NPCFluidPart, value: number, type?: NPCFluidType): NPCFluidData;
+    add(npcName: string, part: NPCFluidPart, value?: number, type?: NPCFluidType): NPCFluidData;
+    reduce(npcName: string, part: NPCFluidPart, value?: number, type?: NPCFluidType): NPCFluidData;
+    clear(npcName: string, part?: NPCFluidPart, type?: NPCFluidType): NPCFluidData;
+    decay(value?: number): void;
+    apply(nnpc: Record<string, any>, npcData: any): void;
+}
+export default NPCFluids;

package/modules/NamedNPCAddon/NPCPregnancy.d.ts

@@ -0,0 +1,127 @@
+import type NPCManager from '../NamedNPC.js';
+export type NPCPregnancySpecies = 'human' | 'wolf' | 'wolfboy' | 'wolfgirl' | 'hawk' | 'harpy';
+export type NPCPregnancyOrifice = 'vagina' | 'anus';
+export type NPCPregnancyRange = number | readonly [min: number, max: number];
+export interface NPCPregnancyState {
+    enabled?: boolean;
+    analEnabled?: boolean;
+    cycleDaysTotal?: number;
+    cycleDay?: number;
+    cycleDangerousDay?: number;
+    fertileLeadDays?: number;
+    pills?: 'contraceptive' | 'fertility' | null;
+    [key: string]: unknown;
+}
+export interface NPCPregnancyRecord {
+    pregnancyId: number;
+    carrier: string;
+    carrierSpecies: string;
+    donor: string;
+    donorSpecies: NPCPregnancySpecies;
+    possibleDonors: {
+        name: string;
+        species: NPCPregnancySpecies;
+    }[];
+    conceivedDate: number;
+    conceivedLocation: string;
+    gestationVariance: number;
+    orifice: NPCPregnancyOrifice;
+    deliveredDate: number | null;
+    deliveredLocation: string | null;
+    awareOfPregnancy: string[];
+    awareOfCarrier: string[];
+    awareOfDonor: string[];
+    talkedAbout: Record<string, boolean>;
+    playerLearnedFrom: string | null;
+    hatchDelay?: number;
+    layCare?: number;
+    waterBreaking?: boolean;
+}
+export interface NPCChildRecord {
+    childId: number;
+    pregnancyId: number;
+    species: 'human' | 'wolf' | 'hawk';
+    features: {
+        beastTransform: string | null;
+        divineTransform: string | null;
+        hairColour: string;
+        eyeColour: string;
+        skinColour: string | number;
+        size: 'tiny' | 'small' | 'normal' | 'large';
+        monster?: 'monster';
+    };
+    gender: 'm' | 'f' | 'h';
+    identical: number | null;
+    development: Record<string, unknown>;
+    bornDate: number | null;
+    name: string | null;
+    coParents: string[];
+    awareOfChild: string[];
+    awareOfGender: string[];
+}
+export interface NPCPregnancyCycleConfig {
+    days?: NPCPregnancyRange;
+    dangerousDay?: number;
+    fertileLeadDays?: NPCPregnancyRange;
+    pills?: 'contraceptive' | 'fertility' | null;
+    analEnabled?: boolean;
+    avoidance?: number;
+}
+export interface NPCPregnancyConfig {
+    canBePregnant?: boolean;
+    canImpregnatePlayer?: boolean;
+    cycle?: NPCPregnancyCycleConfig;
+}
+export interface NPCTryConceiveOptions {
+    donor?: string;
+    donorSpecies?: NPCPregnancySpecies;
+    orifice?: NPCPregnancyOrifice;
+    depth?: 'outside' | 'imminent' | 'deep';
+    location?: string;
+    fertility?: number;
+    aware?: boolean;
+    donorKnown?: boolean;
+}
+export interface NPCPregnancySnapshot {
+    cycle: {
+        enabled: boolean;
+        day: number | null;
+        days: number | null;
+        dangerousDay: number | null;
+        fertileLeadDays: number | null;
+        fertility: number;
+        pills: NPCPregnancyState['pills'];
+        analEnabled: boolean;
+        avoidance: number | null;
+    };
+    pregnancies: NPCPregnancyRecord[];
+    progress: number | null;
+    dueDate: number | null;
+    belly: number;
+}
+export declare function isPregnancySpecies(value: unknown): value is NPCPregnancySpecies;
+declare class NPCPregnancy {
+    private readonly manager;
+    private readonly configs;
+    private initialized;
+    constructor(manager: NPCManager);
+    get available(): boolean;
+    add(npcName: string, config?: NPCPregnancyConfig): this;
+    init(): void;
+    inject(): void;
+    get(npcName: string): NPCPregnancySnapshot;
+    tryConceive(npcName: string, options?: NPCTryConceiveOptions): NPCPregnancyRecord | null;
+    private applyRegistration;
+    private applyCycle;
+    private validateCycle;
+    private validateRange;
+    private cycleConfigured;
+    private markCycleConfigured;
+    private species;
+    private name;
+    private npc;
+    private requireRuntime;
+    private range;
+    private random;
+}
+export default NPCPregnancy;