@scml-dol-maplebirch/types 5.0.4 → 5.1.1

package/modules/Audio.d.ts

@@ -0,0 +1,118 @@
+import { MaplebirchCore } from '../core.js';
+import type { ScopedLog } from '../infra/Diagnostics.js';
+import Playlist, { type PlayModeType } from './AudioAddon/Playlist.js';
+import Track from './AudioAddon/Track.js';
+import Ambience from './AudioAddon/Ambience.js';
+declare const PlayState: {
+    readonly IDLE: 'idle';
+    readonly LOADING: 'loading';
+    readonly PLAYING: 'playing';
+    readonly PAUSED: 'paused';
+    readonly STOPPED: 'stopped';
+};
+type PlayStateType = (typeof PlayState)[keyof typeof PlayState];
+interface AudioEventData {
+    type: string;
+    data?: unknown[];
+    [key: string]: unknown;
+}
+type AudioEventHandler = (eventData: AudioEventData) => void;
+interface AudioProgress {
+    currentTime: number;
+    duration: number;
+    percent: number;
+}
+interface AudioSnapshot {
+    state: PlayStateType;
+    track: Track | null;
+    playlist: string;
+    index: number;
+    length: number;
+    mode: PlayModeType;
+    volume: number;
+    muted: boolean;
+    progress: AudioProgress;
+}
+declare class Audio {
+    readonly core: MaplebirchCore;
+    readonly log: ScopedLog;
+    readonly ambience: Ambience;
+    private readonly STORE;
+    private readonly playlists;
+    private readonly playlistLoads;
+    private readonly eventListeners;
+    private readonly cache;
+    private readonly pendingLoads;
+    private activePlaylist;
+    private currentTrack;
+    private loadingTrack;
+    private currentHowl;
+    private state;
+    private volume;
+    private muted;
+    private autoNext;
+    private maxCache;
+    private cacheCount;
+    private playRequestId;
+    private progressTimer;
+    private progressBindings;
+    constructor(core: MaplebirchCore);
+    private initDB;
+    protected on(event: string, handler: AudioEventHandler): void;
+    protected off(event: string, handler: AudioEventHandler): boolean;
+    protected once(event: string, handler: AudioEventHandler): void;
+    play(track: Track): Promise<boolean>;
+    pause(): boolean;
+    resume(): boolean;
+    stop(): boolean;
+    togglePlayPause(): void;
+    next(): Promise<boolean>;
+    previous(): Promise<boolean>;
+    playAt(modName: string, index: number): Promise<boolean>;
+    seek(percent: number): boolean;
+    seekTo(seconds: number): boolean;
+    getPlaylist(modName: string): Promise<Playlist>;
+    playFromMod(modName: string, audioName?: string): Promise<boolean | string>;
+    import(modName: string, audioFolder?: string): Promise<boolean>;
+    addFile(file: File, modName?: string): Promise<boolean | string>;
+    delete(modName: string, audioName: string): Promise<boolean>;
+    clearAudio(modName: string): Promise<boolean | string>;
+    clearCache(): void;
+    destroy(): void;
+    playlist(modName: string): Playlist;
+    get Mute(): boolean;
+    set Mute(value: boolean);
+    get Volume(): number;
+    set Volume(value: number);
+    get PlayMode(): PlayModeType;
+    set PlayMode(mode: PlayModeType);
+    cyclePlayMode(): PlayModeType;
+    get AutoNext(): boolean;
+    set AutoNext(value: boolean);
+    get State(): PlayStateType;
+    get CurrentTrack(): Track | null;
+    get ActivePlaylist(): Playlist | null;
+    get currentTime(): number;
+    get duration(): number;
+    get progress(): AudioProgress;
+    get snapshot(): AudioSnapshot;
+    formatTime(seconds: number): string;
+    bindProgress(sliderId: string, timeId: string, interval?: number): void;
+    unbindProgress(sliderId: string, timeId: string): void;
+    preInit(): Promise<void>;
+    private load;
+    private save;
+    private readRecords;
+    private cacheAudio;
+    private unloadCache;
+    private trimCache;
+    private release;
+    private stopCurrent;
+    private get outputVolume();
+    private startProgressTimer;
+    private stopProgressTimer;
+    private handleTrackEnd;
+    private dispatch;
+    private emit;
+}
+export default Audio;

package/modules/AudioAddon/Ambience.d.ts

@@ -0,0 +1,17 @@
+import { Howl, type HowlOptions } from 'howler';
+import type ModLoader from '../../host/ModLoader.js';
+declare class Ambience {
+    private readonly modloader;
+    private active;
+    private request;
+    constructor(modloader: ModLoader);
+    protected create(options: HowlOptions): Howl;
+    play(modName: string, path: string, volume?: number, fadeMs?: number): Promise<boolean>;
+    setVolume(volume: number, fadeMs?: number): void;
+    stop(fadeMs?: number): void;
+    private fadeOut;
+    private dispose;
+    private clamp;
+    private duration;
+}
+export default Ambience;

package/modules/AudioAddon/AudioBufferPlayer.d.ts

@@ -0,0 +1,20 @@
+declare class AudioBufferPlayer {
+    private readonly context;
+    private readonly buffer;
+    private readonly onend;
+    private source;
+    private readonly gain;
+    private startedAt;
+    private offset;
+    private playing;
+    constructor(context: AudioContext, buffer: AudioBuffer, volume: number, onend: () => void);
+    play(): void;
+    pause(): void;
+    stop(): void;
+    seek(value?: number): number;
+    duration(): number;
+    volume(value: number): void;
+    unload(): void;
+    private stopSource;
+}
+export default AudioBufferPlayer;

package/modules/AudioAddon/Playlist.d.ts

@@ -0,0 +1,29 @@
+import Track from './Track.js';
+export declare const PlayMode: {
+    readonly SEQUENTIAL: 'sequential';
+    readonly LOOP_ALL: 'loop_all';
+    readonly LOOP_ONE: 'loop_one';
+    readonly SHUFFLE: 'shuffle';
+};
+export type PlayModeType = (typeof PlayMode)[keyof typeof PlayMode];
+declare class Playlist {
+    readonly name: string;
+    tracks: Track[];
+    currentIndex: number;
+    playMode: PlayModeType;
+    private shuffleOrder;
+    private shuffleIndex;
+    constructor(name: string);
+    add(input: Track | Track[]): void;
+    removeAt(index: number): boolean;
+    remove(audioName: string): boolean;
+    clear(): void;
+    setMode(mode: PlayModeType): void;
+    select(index: number): Track | null;
+    next(): Track | null;
+    previous(): Track | null;
+    get length(): number;
+    private resetShuffle;
+    private shuffle;
+}
+export default Playlist;

package/modules/AudioAddon/Track.d.ts

@@ -0,0 +1,15 @@
+type AudioFormat = 'mp3' | 'wav' | 'ogg' | 'm4a' | 'flac' | 'webm';
+interface TrackMeta {
+    title?: string;
+    artist?: string;
+}
+declare class Track {
+    readonly audioName: string;
+    readonly modName: string;
+    title: string;
+    artist: string;
+    duration: number;
+    format: AudioFormat;
+    constructor(audioName: string, modName: string, meta?: TrackMeta);
+}
+export default Track;

package/modules/Character.d.ts

@@ -0,0 +1,39 @@
+import { MaplebirchCore } from '../core.js';
+import type { ScopedLog } from '../infra/Diagnostics.js';
+import type AddonPlugin from '../services/AddonPlugin.js';
+import Pet from './CharacterAddon/Pet.js';
+import Transformation from './CharacterAddon/Transformation.js';
+export type ProcessType = 'pre' | 'post';
+export type ModelTarget<TModel = CanvasModel | CanvasModelOptions> = string | string[] | ((modelName: string, model?: TModel) => boolean);
+export type ProcessHandler = (options: any, model?: CanvasModel) => void;
+interface LayerUseOptions {
+    pet?: boolean;
+}
+declare function mask(x?: number, rotation?: number, swap?: boolean, width?: number, height?: number): string;
+declare class Character {
+    readonly core: MaplebirchCore;
+    readonly log: ScopedLog;
+    readonly mask: typeof mask;
+    readonly faceStyleMap: Map<string, string[]>;
+    private readonly processors;
+    private nextProcessor;
+    private readonly layers;
+    readonly pet: Pet;
+    readonly transformation: Transformation;
+    constructor(core: MaplebirchCore);
+    get ZIndices(): {
+        [key: string]: number;
+    };
+    modifyFaceStyle(manager: AddonPlugin): void;
+    faceStyleImagePaths(files: Record<string, unknown>): void;
+    private faceStyleSetupOption;
+    modifyCanvasModel(manager: AddonPlugin): void;
+    patchCanvasModel<T extends CanvasModelConstructor>(BaseCanvasModel: T): T;
+    use(type: ProcessType, handler: ProcessHandler, target?: ModelTarget<CanvasModel>): this;
+    use(layers: CanvasLayerMap, target?: ModelTarget<CanvasModelOptions>, options?: LayerUseOptions): this;
+    process(type: ProcessType, options: CanvasModelOptionsData, model?: CanvasModel): void;
+    preInit(): void;
+    Init(): void;
+    loadInit(): void;
+}
+export default Character;

package/modules/CharacterAddon/Pet.d.ts

@@ -0,0 +1,61 @@
+import type Character from '../Character.js';
+export interface PetOptions {
+    mask?: number;
+    rotation?: number;
+    animated?: boolean;
+    floating?: boolean;
+    scale?: number;
+}
+export interface PetSettings extends PetOptions {
+    enabled?: boolean;
+}
+type PetTarget = string | HTMLElement;
+interface PetHost {
+    mask(x?: number, rotation?: number): string;
+}
+interface FloatingPetConfig {
+    elementId: string;
+    storageKey: string;
+    className: string;
+    fallback(size: number): {
+        left: number;
+        top: number;
+    };
+}
+export declare abstract class FloatingPet {
+    protected readonly host: PetHost;
+    protected readonly petConfig: FloatingPetConfig;
+    protected canvas?: HTMLCanvasElement;
+    protected model?: CanvasModel;
+    protected container?: HTMLElement;
+    protected options: Required<PetOptions>;
+    private cleanupDrag?;
+    protected constructor(host: PetHost, petConfig: FloatingPetConfig);
+    configure(options?: PetOptions): this;
+    unmount(): void;
+    refresh(): boolean;
+    protected abstract draw(model: CanvasModel, context: CanvasRenderingContext2D): void;
+    protected mount(container: HTMLElement, model: CanvasModel, canvas: HTMLCanvasElement): void;
+    protected stopAnimation(): void;
+    private get displaySize();
+    private clearBox;
+    private enableDrag;
+}
+declare class Pet extends FloatingPet {
+    private manager;
+    readonly modelName: string;
+    private readonly layers;
+    private syncing;
+    private rendering;
+    private syncFrame;
+    constructor(manager: Character);
+    sync(): boolean;
+    use(layers: CanvasLayerMap): this;
+    capture(mainModel?: CanvasModelOptions): void;
+    render(target: PetTarget, options?: PetOptions): boolean;
+    unmount(): void;
+    private cancel;
+    private readSettings;
+    protected draw(model: CanvasModel, context: CanvasRenderingContext2D): void;
+}
+export default Pet;

package/modules/CharacterAddon/Transformation.d.ts

@@ -0,0 +1,70 @@
+import type { Translation } from '../../services/Translator.js';
+import type AddonPlugin from '../../services/AddonPlugin.js';
+import type Character from '../Character.js';
+import { type DecayCondition, type SuppressCondition, type BuildUpdater } from './TransformationConfig.js';
+interface Part {
+    name: string;
+    tfRequired: number;
+    default?: string;
+    [key: string]: any;
+}
+type TransformHook = (options: any, model?: CanvasModel) => void;
+type TransformMessage = Record<string, {
+    up: string[];
+    down: string[];
+}>;
+type TranslationInput = Record<string, Translation> | Map<string, Translation>;
+interface EntryOptions {
+    build?: number;
+    level?: number;
+    update?: number[];
+    icon?: string;
+    message?: TransformMessage;
+    decay?: boolean;
+    decayConditions?: DecayCondition[];
+    suppress?: boolean;
+    suppressConditions?: SuppressCondition[];
+    pre?: TransformHook;
+    post?: TransformHook;
+    layers?: CanvasLayerMap;
+    translations?: TranslationInput;
+}
+interface TransformationOption extends EntryOptions {
+    parts: Part[];
+    traits?: Part[];
+}
+declare class Transformation {
+    private manager;
+    private get log();
+    private config;
+    readonly decayConditions: Record<string, DecayCondition[]>;
+    readonly suppressConditions: Record<string, SuppressCondition[]>;
+    readonly buildUpdaters: Record<string, BuildUpdater>;
+    constructor(manager: Character);
+    private get isDoLP();
+    private get animalTransforms();
+    private get animalMacros();
+    private get historyTransforms();
+    wikifier(widget: string, ...args: any[]): any;
+    modifyEffect(manager: AddonPlugin): void;
+    add(name: string, type: string, options: TransformationOption): this;
+    inject(): void;
+    private _update;
+    state(): void;
+    private _clear;
+    private suppress;
+    _transform(name: string, change: number): void;
+    updateTransform(name: string): void;
+    _updateParts(name: string, oldLevel: number, newLevel: number): void;
+    _transformationAlteration(): void;
+    _transformationStateUpdate(): void;
+    private handleHiddenTransformParts;
+    message(key: string, tools: {
+        element: (tag: string, text: any, className?: string) => void;
+        wikifier: (macro: string, param: string) => void;
+    }): boolean;
+    get icon(): string;
+    setTransform(name: string, level?: number | null): void;
+    part(partName: string): boolean;
+}
+export default Transformation;

package/modules/CharacterAddon/TransformationConfig.d.ts

@@ -0,0 +1,20 @@
+export type DecayCondition = () => boolean;
+export type SuppressCondition = (sourceName: string) => boolean;
+export type BuildUpdater = (change: number) => void;
+export interface NativeTransformState {
+    name: string;
+    level: () => number;
+    build: () => number;
+}
+export type NativeMacroMap = Record<string, [string, () => number]>;
+export interface NativeHistoryEntry {
+    name: string;
+    level: () => number;
+    max: number;
+}
+export declare const DecayConditions: Record<string, DecayCondition[]>;
+export declare const SuppressConditions: Record<string, SuppressCondition[]>;
+export declare const AnimalTransforms: NativeTransformState[];
+export declare const AnimalMacros: NativeMacroMap;
+export declare const HistoryTransforms: NativeHistoryEntry[];
+export declare const BuildUpdaters: Record<string, BuildUpdater>;

package/modules/Combat.d.ts

@@ -0,0 +1,17 @@
+import { type MaplebirchCore } from '../core.js';
+import type { ScopedLog } from '../infra/Diagnostics.js';
+import CombatActions from './CombatAddon/CombatAction.js';
+declare class Combat {
+    readonly core: MaplebirchCore;
+    readonly log: ScopedLog;
+    readonly CombatAction: CombatActions;
+    private readonly pendingDefaults;
+    constructor(core: MaplebirchCore);
+    preInit(): void;
+    private _assignCombatDefaults;
+    private _generateCombatAction;
+    private _combatListColor;
+    private _combatButtonAdjustments;
+    Init(): void;
+}
+export default Combat;

package/modules/CombatAddon/CombatAction.d.ts

@@ -0,0 +1,63 @@
+import type { ActionType, CombatType } from './CombatTypes.js';
+export { actionTypes, combatTypes } from './CombatTypes.js';
+export type { ActionType, CombatType } from './CombatTypes.js';
+export type OptionType = ActionType | 'ask';
+export type ActionValue = string | number;
+interface Context {
+    actionType?: OptionType;
+    combatType?: CombatType;
+    encounterType?: CombatType;
+    action?: ActionValue;
+    id?: string;
+    originalCount?: number;
+    label?: string;
+}
+interface ActionEntry {
+    id: string;
+    actionType: ActionType;
+    cond: (ctx: Context) => boolean;
+    display: (ctx: Context) => string;
+    value: (ctx: Context) => ActionValue;
+    color: (ctx: Context) => string;
+    difficulty: (ctx: Context) => string;
+    effect: (ctx: Context) => string;
+    combatType: (ctx: Context) => CombatType | CombatType[];
+    order: (ctx: Context) => number;
+}
+interface ActionConfig {
+    id: string;
+    actionType: ActionType | ActionType[];
+    cond: (ctx: Context) => boolean;
+    display: (ctx: Context) => string;
+    value: (ctx: Context) => ActionValue;
+    color?: string | ((ctx: Context) => string);
+    difficulty?: string | ((ctx: Context) => string);
+    effect?: string | ((ctx: Context) => string);
+    combatType?: CombatType | CombatType[] | ((ctx: Context) => CombatType | CombatType[]);
+    order?: number | ((ctx: Context) => number);
+}
+interface ModificationConfig {
+    id: string;
+    actionType: OptionType | OptionType[];
+    value: ActionValue;
+    combatType?: CombatType | CombatType[] | ((ctx: Context) => CombatType | CombatType[]);
+    cond?: (ctx: Context) => boolean;
+    display?: string | ((ctx: Context) => string);
+    order?: number | ((ctx: Context) => number);
+}
+export interface OptionsTable {
+    [key: string]: ActionValue;
+}
+declare class CombatActions {
+    readonly actions: ActionEntry[];
+    private readonly modifications;
+    private matches;
+    reg(...configs: ActionConfig[]): this;
+    modify(...configs: ModificationConfig[]): this;
+    private eval;
+    patchOptions(optionsTable: OptionsTable, actionType: OptionType, combatType?: CombatType): OptionsTable;
+    color(action: ActionValue, encounterType?: CombatType): string | null;
+    difficulty(action: ActionValue, combatType?: CombatType): string | null;
+    effect(combatType: CombatType | undefined, ...actionTypes: ActionType[]): string;
+}
+export default CombatActions;

package/modules/CombatAddon/CombatTypes.d.ts

@@ -0,0 +1,4 @@
+export declare const actionTypes: readonly ['leftaction', 'rightaction', 'feetaction', 'mouthaction', 'penisaction', 'vaginaaction', 'anusaction', 'chestaction', 'thighaction'];
+export type ActionType = (typeof actionTypes)[number];
+export declare const combatTypes: readonly ['Default', 'Self', 'Struggle', 'Swarm', 'Vore', 'Machine', 'Tentacle'];
+export type CombatType = (typeof combatTypes)[number];

package/modules/DoL/Config.d.ts

@@ -0,0 +1,50 @@
+import type { MaplebirchCore } from '../../core.js';
+import type { BootTask } from '../../services/AddonPlugin.js';
+import type { zonesManager, ZoneWidgetConfig } from '../Frameworks/ZonesManager.js';
+import type { Patches } from './Patches/index.js';
+import type { BodywritingConfig } from './Patches/Bodywriting.js';
+import type { FoodstuffConfig } from './Patches/Foodstuff.js';
+import type { AntiqueConfig } from './Patches/Antiques.js';
+import type { FishConfig, FishingLocation } from './Patches/Fishing.js';
+type ConfigFileSource = string | string[];
+type KeyedConfig<T> = T & {
+    key?: string;
+};
+interface TraitBootConfig {
+    title?: string;
+    name?: string;
+    colour?: string;
+    has?: boolean | string;
+    text?: string;
+}
+type TraitConfigSource = TraitBootConfig[] | ConfigFileSource;
+type BodywritingConfigSource = KeyedConfig<BodywritingConfig>[] | Record<string, BodywritingConfig> | ConfigFileSource;
+type FoodstuffConfigSource = KeyedConfig<FoodstuffConfig>[] | Record<string, FoodstuffConfig> | ConfigFileSource;
+type AntiquesConfigSource = KeyedConfig<AntiqueConfig>[] | Record<string, AntiqueConfig> | ConfigFileSource;
+type TipsConfigSource = string[] | Record<string, string[]> | ConfigFileSource;
+type FrameworkWidgetConfig = string | ZoneWidgetConfig | [number, string | ZoneWidgetConfig];
+export interface FrameworkConfig {
+    traits?: TraitConfigSource;
+    bodywriting?: BodywritingConfigSource;
+    foodstuff?: FoodstuffConfigSource;
+    antiques?: AntiquesConfigSource;
+    tips?: TipsConfigSource;
+    fish?: KeyedConfig<FishConfig>[] | Record<string, FishConfig> | ConfigFileSource;
+    bait?: FoodstuffConfigSource;
+    fishingLocations?: Partial<Record<FishingLocation, Record<string, number>>> | ConfigFileSource;
+    addto?: string;
+    widget?: FrameworkWidgetConfig;
+}
+declare class FrameworkConfigLoader {
+    private readonly core;
+    private readonly patch;
+    private readonly zone;
+    private readonly handlers;
+    constructor(core: MaplebirchCore, patch: Patches, zone: zonesManager);
+    apply(task: BootTask<FrameworkConfig | FrameworkConfig[]>): Promise<void>;
+    private loadSources;
+    private addTrait;
+    private addKeyedConfig;
+    private addTips;
+}
+export default FrameworkConfigLoader;

package/modules/DoL/Dynamic.d.ts

@@ -0,0 +1,23 @@
+import BaseDynamic from '../Dynamic.js';
+import type { StateEventOptions, StateManager } from '../State.js';
+import { TimeManager, type TimeEventOptions, type TimeTravelOptions, type TimeEventType } from '../TimeStateWeather/TimeEvents.js';
+import { WeatherManager, type WeatherEventOptions, type WeatherTypeConfig, type WeatherException } from '../TimeStateWeather/WeatherEvents.js';
+declare class DoLDynamic extends BaseDynamic {
+    get State(): StateManager;
+    get Time(): TimeManager;
+    get Weather(): WeatherManager;
+    regStateEvent(type: 'gate' | 'append', eventId: string, options: StateEventOptions): boolean;
+    delStateEvent(type: 'gate' | 'append', eventId: string): boolean;
+    trigger(type: 'gate' | 'append'): string;
+    get StateEvents(): StateManager['events'];
+    regTimeEvent(type: TimeEventType, eventId: string, options: TimeEventOptions): boolean;
+    delTimeEvent(type: TimeEventType, eventId: string): boolean;
+    timeTravel(options?: TimeTravelOptions): boolean;
+    get TimeEvents(): TimeManager['events'];
+    regWeatherEvent(eventId: string, options: WeatherEventOptions): boolean;
+    delWeatherEvent(eventId: string): boolean;
+    addWeather(data: WeatherException | WeatherTypeConfig): boolean | void;
+    Init(): void;
+    private fixDynamicTask;
+}
+export default DoLDynamic;

package/modules/DoL/Integration.d.ts

@@ -0,0 +1,13 @@
+import type { MaplebirchCore } from '../../core.js';
+declare class DoLIntegration {
+    private readonly core;
+    constructor(core: MaplebirchCore);
+    install(): void;
+    private filterOriginalImagePack;
+    private preparePatch;
+    private patchTimeScripts;
+    private preloadFaceStyles;
+    private configureBeautySelector;
+    private modifyOptionsDateFormat;
+}
+export default DoLIntegration;

package/modules/DoL/Patches/Antiques.d.ts

@@ -0,0 +1,17 @@
+export interface AntiqueConfig {
+    hint: string;
+    museum: string;
+    name: string;
+    cn_name?: string;
+    journal: string;
+    journalName?: string;
+    icon: string;
+    key?: string;
+}
+export declare const antiquesData: Record<string, AntiqueConfig>;
+declare class Antiques {
+    static add(key: string, config: AntiqueConfig): void;
+    static inject(data: Record<string, AntiqueConfig>): Record<string, AntiqueConfig>;
+    static syncState(): void;
+}
+export default Antiques;

package/modules/DoL/Patches/Bodywriting.d.ts

@@ -0,0 +1,33 @@
+export interface BodywritingConfig {
+    writing?: string;
+    writ_cn?: string;
+    type?: 'text' | 'object';
+    arrow?: 0 | 1;
+    special?: string;
+    gender?: 'n' | 'f' | 'm' | 'h';
+    lewd?: 0 | 1;
+    degree?: number;
+    featSkip?: boolean;
+    sprites?: string[];
+    index?: number;
+    key?: string;
+}
+export type BodywritingData = {
+    operation: 'add';
+    config: BodywritingConfig;
+} | {
+    operation: 'del';
+};
+export type BodywritingItem = BodywritingConfig & {
+    index: number;
+    key: string;
+};
+export declare const bodywritingData: Record<string, BodywritingData>;
+declare class Bodywriting {
+    static add(key: string, config: BodywritingConfig): void;
+    static delete(key: string): void;
+    static apply(): void;
+    private static remove;
+    private static set;
+}
+export default Bodywriting;

package/modules/DoL/Patches/Fishing.d.ts

@@ -0,0 +1,32 @@
+import { type FoodstuffConfig } from './Foodstuff.js';
+export type FishingLocation = 'fishingBeach' | 'fishingPier' | 'fishingCoastPath' | 'fishingForestLake' | 'fishingMoor';
+export type FishingSeason = 'spring' | 'summer' | 'autumn' | 'winter';
+export type FishBehavior = 'runner' | 'darter' | 'panicked' | 'anchor' | 'thrasher' | 'slipper';
+export interface FishConfig {
+    minSize: number;
+    maxSize: number;
+    locations: Partial<Record<FishingLocation, number>>;
+    icon: string;
+    preferredSeason?: FishingSeason[];
+    preferredLocation?: FishingLocation[];
+    preferredBait?: string;
+    cookable?: boolean;
+    requiresBaitFish?: boolean;
+    isBaitFish?: boolean;
+    minigame?: {
+        behavior: FishBehavior;
+        maxStamina: number;
+        armFatigueDifficulty: number;
+    };
+    foodstuff?: FoodstuffConfig;
+}
+export type FishData = Omit<FishConfig, 'foodstuff'> & Required<Pick<FishConfig, 'preferredSeason' | 'preferredLocation' | 'cookable'>>;
+export declare const fishData: Record<string, FishConfig>;
+export declare const fishingLocationData: Partial<Record<FishingLocation, Record<string, number>>>;
+declare class Fishing {
+    static addFish(key: string, config: FishConfig): boolean;
+    static addBait(key: string, config: FoodstuffConfig): void;
+    static configureLocation(location: FishingLocation, weights: Record<string, number>): boolean;
+    static apply(): void;
+}
+export default Fishing;