@scml-dol-maplebirch/types 5.0.3 → 5.1.0

package/types/twine-sugarcube.d.ts

@@ -0,0 +1,456 @@
+import type { BrowserAPI } from '@scml/sc2-verlnir/src/browser';
+import type { ConfigAPI } from '@scml/sc2-verlnir/src/config';
+import type { DebugBarAPI } from '@scml/sc2-verlnir/src/debugbar';
+import type { DialogAPI } from '@scml/sc2-verlnir/src/dialog';
+import type { EngineAPI } from '@scml/sc2-verlnir/src/engine';
+import type { FullscreenAPI } from '@scml/sc2-verlnir/src/fullscreen';
+import type { HasAPI } from '@scml/sc2-verlnir/src/has';
+import type { L10nAPI } from '@scml/sc2-verlnir/src/l10n';
+import type { MacroAPI } from '@scml/sc2-verlnir/src/macro';
+import type { PassageConstructor } from '@scml/sc2-verlnir/src/passage';
+import type { SaveAPI as VerlnirSaveAPI } from '@scml/sc2-verlnir/src/save';
+import type { ScriptingAPI } from '@scml/sc2-verlnir/src/scripting';
+import type { SettingAPI } from '@scml/sc2-verlnir/src/setting';
+import type { SimpleAudioAPI } from '@scml/sc2-verlnir/src/simpleaudio';
+import type { SimpleStoreInstanceAPI } from '@scml/sc2-verlnir/src/simplestore';
+import type { StoryAPI } from '@scml/sc2-verlnir/src/story';
+import type { UIAPI } from '@scml/sc2-verlnir/src/ui';
+import type { UIBarAPI } from '@scml/sc2-verlnir/src/uibar';
+import type { UtilAPI } from '@scml/sc2-verlnir/src/util';
+import type { VersionInfo } from '@scml/sc2-verlnir/src/version';
+import type { VisibilityAPI } from '@scml/sc2-verlnir/src/visibility';
+import type { WikifierAPI as VerlnirWikifierAPI } from '@scml/sc2-verlnir/src/wikifier';
+import type { BodywritingItem } from '../modules/DoL/Patches/Bodywriting.js';
+import type { FoodstuffItem } from '../modules/DoL/Patches/Foodstuff.js';
+import type { LocationConfig } from '../modules/DoL/Patches/Location.js';
+import type { FishData } from '../modules/DoL/Patches/Fishing.js';
+import type { AntiqueConfig } from '../modules/DoL/Patches/Antiques.js';
+import type { TraitCategory } from '../modules/DoL/Patches/Traits.js';
+import type { SugarCubeStoryVariables, SugarCubeTemporaryVariables } from 'twine-sugarcube/userdata';
+declare module 'twine-sugarcube/userdata' {
+    interface SugarCubeSetupObject {
+        bodywriting: Record<string, BodywritingItem>;
+        bodywriting_namebyindex: (string | undefined)[];
+        foodstuff: Record<string, FoodstuffItem>;
+        LocationImages: Record<string, LocationConfig>;
+        Locations: Record<string, () => string>;
+        tips: Record<string, string[]>;
+        tipsList: string[];
+        fishing?: {
+            lootTables: {
+                fish: Record<string, FishData>;
+            };
+        };
+        [x: string]: any;
+    }
+    interface SugarCubeStoryVariables {
+        foodstuff: Record<string, {
+            amount: number;
+            [key: string]: unknown;
+        }>;
+        museumAntiques?: {
+            antiques: Record<string, string>;
+            maxCount: number;
+            [key: string]: unknown;
+        };
+        [x: string]: any;
+    }
+    interface SugarCubeTemporaryVariables {
+        traitLists: TraitCategory[];
+        museumAntiqueText: Record<string, AntiqueConfig>;
+        [x: string]: any;
+    }
+}
+declare module 'twine-sugarcube' {
+    interface WikifierAPI {
+        wikifyEval(text: string, passageObj?: {
+            title: string;
+        }, passageTitle?: string): DocumentFragment;
+    }
+    interface MacroDefinition {
+        isAsync?: boolean;
+        isWidget?: boolean;
+    }
+}
+export interface DolStateMoment {
+    readonly title: string;
+    readonly variables: Record<string, unknown>;
+}
+export interface DolStateMetadataAPI {
+    clear(): void;
+    delete(key: string): boolean;
+    entries(): Iterable<[string, unknown]>;
+    get(key: string): unknown;
+    has(key: string): boolean;
+    keys(): Iterable<string>;
+    set(key: string, value: unknown): void;
+    readonly size: number;
+}
+export interface DolStatePRNGAPI {
+    init(seed: string | number): void;
+    isEnabled(): boolean;
+    pull: number;
+    readonly seed: string | number;
+    str2int(str: string): number;
+    test(seed: string | number): boolean;
+    peek(): number;
+}
+export interface DolStateAPI {
+    reset(): void;
+    restore(soft?: boolean): boolean;
+    marshalForSave(): unknown;
+    unmarshalForSave(stateObj: unknown): void;
+    readonly expired: string[];
+    readonly passages: string[];
+    getSessionState(): unknown;
+    setSessionState(state: unknown): void;
+    readonly active: DolStateMoment;
+    readonly activeIndex: number;
+    readonly current: DolStateMoment | undefined;
+    readonly top: DolStateMoment | undefined;
+    readonly bottom: DolStateMoment | undefined;
+    readonly history: DolStateMoment[];
+    readonly passage: string;
+    readonly variables: Record<string, unknown>;
+    readonly temporary: Record<string, unknown>;
+    readonly length: number;
+    readonly size: number;
+    readonly turns: number;
+    create(): DolStateMoment;
+    goTo(index: number): void;
+    go(delta: number): void;
+    deltaEncode(moments: DolStateMoment[]): unknown;
+    deltaDecode(data: unknown): DolStateMoment[];
+    readonly prng: DolStatePRNGAPI;
+    clearTemporary(): void;
+    pushLocal(): void;
+    popLocal(): Record<string, unknown> | undefined;
+    peekLocal(): Record<string, unknown> | undefined;
+    readonly local: Record<string, unknown>;
+    clearLocal(): void;
+    getVar(path: string): unknown;
+    setVar(path: string, value: unknown): void;
+    has(offset: number): boolean;
+    hasPlayed(passage: string): boolean;
+    index(offset?: number): number;
+    isEmpty(): boolean;
+    peek(offset?: number): DolStateMoment | undefined;
+    random(): number;
+    readonly metadata: DolStateMetadataAPI;
+    readonly qc: unknown;
+    qcadd(fn: (...args: unknown[]) => void): void;
+    initPRNG(seed: string | number): void;
+    restart(): void;
+    backward(): void;
+    forward(): void;
+    display(...args: unknown[]): void;
+    show(...args: unknown[]): void;
+    play(...args: unknown[]): void;
+}
+export interface DolSaveAPI extends VerlnirSaveAPI {
+    serialize(metadata?: unknown): string;
+    deserialize(saveStr: string): unknown;
+}
+export type WikifierAPI = VerlnirWikifierAPI & {
+    wikifyEval(text: string, passageObj?: {
+        title: string;
+    }, passageTitle?: string): DocumentFragment;
+};
+export type SugarCubeUtilAPI = UtilAPI;
+export interface TwineSugarCube {
+    Browser: BrowserAPI;
+    Config: ConfigAPI;
+    Dialog: DialogAPI;
+    Engine: EngineAPI;
+    Fullscreen: FullscreenAPI;
+    Has: HasAPI;
+    L10n: L10nAPI;
+    Macro: MacroAPI;
+    Passage: PassageConstructor;
+    Save: DolSaveAPI;
+    Scripting: ScriptingAPI;
+    Setting: SettingAPI;
+    SimpleAudio: SimpleAudioAPI;
+    State: DolStateAPI;
+    Story: StoryAPI;
+    UI: UIAPI;
+    UIBar: UIBarAPI;
+    DebugBar: DebugBarAPI;
+    Util: SugarCubeUtilAPI;
+    Visibility: VisibilityAPI;
+    Wikifier: WikifierAPI;
+    session: SimpleStoreInstanceAPI | null;
+    settings: Record<string, unknown>;
+    setup: Record<string, unknown>;
+    storage: SimpleStoreInstanceAPI | null;
+    version: VersionInfo;
+}
+declare global {
+    const V: SugarCubeStoryVariables;
+    const C: Record<string, any>;
+    const T: SugarCubeTemporaryVariables;
+    interface DateTimeData {
+        year: number;
+        month: number;
+        day: number;
+        hour?: number;
+        minute?: number;
+        second?: number;
+        timeStamp: number;
+    }
+    interface DateTimeDiff {
+        years: number;
+        months: number;
+        days: number;
+        hours: number;
+        minutes: number;
+        seconds: number;
+    }
+    interface DateTimeConstructor {
+        readonly MIN_DATE: DateTime;
+        readonly MAX_DATE: DateTime;
+        new (timestamp?: number): DateTime;
+        new (date: DateTimeData): DateTime;
+        new (year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: number): DateTime;
+        toSerialYear(year: number): number;
+        fromSerialYear(serialYear: number): number;
+        getTotalDaysSinceStart(year: number): number;
+        isLeapYear(year: number): boolean;
+        getDaysOfMonthFromYear(year: number): readonly number[];
+        getDaysOfYear(year: number): number;
+    }
+    class DateTime implements DateTimeData {
+        static readonly MIN_DATE: DateTime;
+        static readonly MAX_DATE: DateTime;
+        constructor(timestamp?: number);
+        constructor(date: DateTimeData);
+        constructor(year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: number);
+        year: number;
+        month: number;
+        day: number;
+        hour: number;
+        minute: number;
+        second: number;
+        timeStamp: number;
+        static toSerialYear(year: number): number;
+        static fromSerialYear(serialYear: number): number;
+        static getTotalDaysSinceStart(year: number): number;
+        static isLeapYear(year: number): boolean;
+        static getDaysOfMonthFromYear(year: number): readonly number[];
+        static getDaysOfYear(year: number): number;
+        toTimestamp(year: number, month: number, day: number, hour: number, minute: number, second: number): this;
+        fromTimestamp(timestamp: number): this;
+        compareWith(otherDateTime: DateTime, getSeconds?: boolean): number | DateTimeDiff;
+        dayDifference(otherDateTime: DateTime): number;
+        getFirstWeekdayOfMonth(weekDay: number): DateTime;
+        getNextWeekdayDate(weekDay: number): DateTime;
+        getPreviousWeekdayDate(weekDay: number): DateTime;
+        addYears(years: number): this;
+        addMonths(months: number): this;
+        addDays(days: number): this;
+        addHours(hours: number): this;
+        addMinutes(minutes: number): this;
+        addSeconds(seconds: number): this;
+        isLastDayOfMonth(): boolean;
+        isFirstDayOfMonth(): boolean;
+        between(startDate: DateTime, endDate: DateTime): boolean;
+        readonly midnight: DateTime;
+        readonly dayState: string;
+        readonly weekDay: number;
+        readonly weekDayName: string;
+        readonly monthName: string;
+        readonly weekEnd: boolean;
+        readonly lastDayOfMonth: number;
+        readonly yearDay: number;
+        readonly moonPhaseFraction: number;
+        readonly fractionOfDay: number;
+        readonly fractionOfDayFromNoon: number;
+        readonly simplifiedDayFactor: number;
+        readonly fractionOfYear: number;
+        readonly seasonFactor: number;
+    }
+    interface MoonPhase {
+        start: number;
+        end: number;
+        endAlt?: number;
+        description: string;
+    }
+    interface TimeAPI {
+        readonly date: DateTime;
+        readonly holidayMonths: number[];
+        readonly second: number;
+        readonly minute: number;
+        readonly hour: number;
+        readonly weekDay: number;
+        readonly weekDayName: string;
+        readonly monthDay: number;
+        readonly month: number;
+        readonly monthName: string;
+        readonly year: number;
+        readonly days: number;
+        readonly season: string;
+        readonly tomorrow: DateTime;
+        readonly yesterday: DateTime;
+        readonly schoolTerm: boolean;
+        readonly schoolDay: boolean;
+        readonly schoolTime: boolean;
+        readonly dayState: string;
+        readonly nextSchoolTermStartDate: DateTime;
+        readonly nextSchoolTermEndDate: DateTime;
+        readonly lastDayOfMonth: number;
+        readonly dayOfYear: number;
+        readonly secondsSinceMidnight: number;
+        readonly currentMoonPhase: string;
+        startDate: DateTime;
+        monthNames: string[];
+        daysOfWeek: string[];
+        moonPhases: Record<string, MoonPhase>;
+        set(time?: number | DateTime): void;
+        setDate(date: DateTime): void;
+        setTime(hour: number, minute?: number): void;
+        setTimeRelative(hour?: number, minute?: number): void;
+        pass(seconds: number): any;
+        timeTravel(date: DateTime): any;
+        isSchoolTerm(date: DateTime): boolean;
+        isSchoolDay(date: DateTime): boolean;
+        isSchoolTime(date: DateTime): boolean;
+        getDayOfYear(date: DateTime): number;
+        getSecondsSinceMidnight(date: DateTime): number;
+        nextMoonPhase(targetPhase: string): DateTime;
+        previousMoonPhase(targetPhase: string): DateTime;
+        isBloodMoon(date?: DateTime): boolean;
+        getSeason(date: DateTime): string;
+        getNextSchoolTermStartDate(date: DateTime): DateTime;
+        getNextSchoolTermEndDate(date: DateTime): DateTime;
+        getNextWeekdayDate(weekDay: number): DateTime;
+        getPreviousWeekdayDate(weekDay: number): DateTime;
+        isWeekEnd(): boolean;
+        hasDatePassed(month: number, day: number): boolean;
+        betweenHours(from: number, to: number, pass?: number): boolean;
+        openingHours(minutes?: number): boolean;
+        readonly oxygenResaturationDuration: number;
+    }
+    const Time: TimeAPI;
+    type CanvasLayerMap = Record<string, LayerConfig>;
+    type CanvasLayerFilter = string | Record<string, any>;
+    type CanvasLayerSrc = string | string[] | undefined;
+    type CanvasLayerMask = string | {
+        path: string;
+        offsetX?: number;
+        offsetY?: number;
+        convert?: boolean;
+    };
+    type CanvasLayerMaskSrc = CanvasLayerMask | CanvasLayerMask[] | undefined;
+    interface CanvasLayerWorn {
+        slot: string;
+        integrity: string | number;
+        alt?: string;
+        index: number;
+    }
+    type CanvasLayerValueFn<T = any> = (options: any) => T;
+    interface CanvasModelOptionsData {
+        filters?: Record<string, any>;
+        generatedLayers?: CanvasLayerMap;
+        [key: string]: any;
+    }
+    interface LayerConfig {
+        name?: string;
+        model?: CanvasModel;
+        defaultOptions?: LayerConfig;
+        show?: boolean;
+        src?: CanvasLayerSrc;
+        z?: number;
+        alpha?: number;
+        maskAlpha?: number;
+        brightness?: number;
+        contrast?: number;
+        blend?: string;
+        blendMode?: string;
+        maskBlendMode?: string;
+        compositeOperation?: string;
+        desaturate?: boolean;
+        masksrc?: CanvasLayerMaskSrc;
+        animation?: any;
+        filters?: CanvasLayerFilter[];
+        dx?: number;
+        dy?: number;
+        width?: number;
+        height?: number;
+        worn?: CanvasLayerWorn;
+        scale?: boolean | number;
+        frameDx?: number;
+        frameDy?: number;
+        showfn?: CanvasLayerValueFn<boolean>;
+        srcfn?: CanvasLayerValueFn<CanvasLayerSrc>;
+        zfn?: CanvasLayerValueFn<number>;
+        alphafn?: CanvasLayerValueFn<number>;
+        maskAlphafn?: CanvasLayerValueFn<number>;
+        brightnessfn?: CanvasLayerValueFn<number>;
+        contrastfn?: CanvasLayerValueFn<number>;
+        blendfn?: CanvasLayerValueFn<string | undefined>;
+        blendModefn?: CanvasLayerValueFn<string | undefined>;
+        maskBlendModefn?: CanvasLayerValueFn<string | undefined>;
+        compositeOperationfn?: CanvasLayerValueFn<string | undefined>;
+        desaturatefn?: CanvasLayerValueFn<boolean>;
+        masksrcfn?: CanvasLayerValueFn<CanvasLayerMaskSrc>;
+        animationfn?: CanvasLayerValueFn<any>;
+        filtersfn?: CanvasLayerValueFn<CanvasLayerFilter[] | undefined>;
+        dxfn?: CanvasLayerValueFn<number>;
+        dyfn?: CanvasLayerValueFn<number>;
+        widthfn?: CanvasLayerValueFn<number>;
+        heightfn?: CanvasLayerValueFn<number>;
+        wornfn?: CanvasLayerValueFn<CanvasLayerWorn | undefined>;
+        scalefn?: CanvasLayerValueFn<boolean | number | undefined>;
+        [key: string]: any;
+    }
+    interface CanvasModelOptions {
+        name: string;
+        width: number;
+        height: number;
+        layers: CanvasLayerMap;
+        frames?: number;
+        metadata?: Record<string, any>;
+        scale?: boolean | number;
+        generatedOptions?: (this: CanvasModel) => any[];
+        defaultOptions?: (this: CanvasModel) => CanvasModelOptionsData;
+        preprocess?: (this: CanvasModel, options: any) => void;
+        postprocess?: (this: CanvasModel, options: any) => void;
+        [key: string]: any;
+    }
+    interface CanvasModelConstructor {
+        new (...args: any[]): CanvasModel;
+        create(id: string, slot?: string): CanvasModel;
+    }
+    class CanvasModel {
+        static create(id: string, slot?: string): CanvasModel;
+        constructor(...args: any[]);
+        name: string;
+        width: number;
+        height: number;
+        frames: number;
+        metadata: Record<string, any>;
+        scale: boolean | number;
+        layers: CanvasLayerMap;
+        layerList: LayerConfig[];
+        options: CanvasModelOptionsData;
+        animated: boolean;
+        canvas: CanvasRenderingContext2D | null;
+        listener?: any;
+        rendererListener?: any;
+        generatedOptions(): any[];
+        defaultOptions(): CanvasModelOptionsData;
+        createCanvas(cssAnimated?: boolean): CanvasRenderingContext2D;
+        reset(): void;
+        showLayer(name: string, filters: CanvasLayerFilter[]): void;
+        hideLayer(name: string): void;
+        render(canvas: CanvasRenderingContext2D, options?: any, listener?: any): void;
+        animate(canvas: CanvasRenderingContext2D, options?: any, listener?: any): any;
+        redraw(): any;
+        preprocess(options: any): void;
+        postprocess(options: any): void;
+        compile(options?: any): LayerConfig[];
+    }
+    export interface JQueryAriaClickOptions {
+        role?: string;
+    }
+}

package/utils/array.d.ts

@@ -0,0 +1,10 @@
+export type ContainsMode = 'all' | 'any' | 'none';
+export type ContainsOptions = {
+    case?: boolean;
+    compare?: (item: unknown, value: unknown) => boolean;
+    deep?: boolean;
+};
+export declare function contains(array: readonly unknown[], value: unknown, mode?: ContainsMode, options?: ContainsOptions): boolean;
+export declare function randomNumber(min?: number, max?: number, float?: boolean): number;
+export declare function randomPick<T>(items: readonly T[], weights?: readonly number[] | null, allowNull?: boolean): T | null | undefined;
+export declare function clamp(value: unknown, min: number, max: number, fallback?: number): number;

package/utils/binary.d.ts

@@ -0,0 +1,8 @@
+export declare function textToBytes(value: string): Uint8Array;
+export declare function jsonToBytes(value: unknown): Uint8Array;
+export declare function bytesToJson<T = unknown>(bytes: Uint8Array | ArrayBuffer): T;
+export declare function toArrayBuffer(bytes: Uint8Array): ArrayBuffer;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function base64ToBytes(value: string): Uint8Array;
+export declare function base64ToArrayBuffer(value: string): ArrayBuffer;
+export declare function basicAuth(username: string, password: string): string;

package/utils/condition.d.ts

@@ -0,0 +1 @@
+export declare function compileBooleanExpression(expression: string): () => boolean;

package/utils/index.d.ts

@@ -0,0 +1,22 @@
+import { clone, equal, merge, append, cover, mergeFn, appendFn, coverFn } from './object.js';
+import { contains, randomNumber as random, randomPick as either, clamp } from './array.js';
+import { convert, escapeHtmlText, widgets } from './string.js';
+import { textToBytes, jsonToBytes, bytesToJson, toArrayBuffer, bytesToBase64, base64ToBytes, base64ToArrayBuffer, basicAuth } from './binary.js';
+import { SelectCase } from './selector.js';
+export { clone, equal, merge, append, cover, mergeFn as mergefn, appendFn as appendfn, coverFn as coverfn, contains, random, either, clamp, convert, escapeHtmlText, widgets, textToBytes, jsonToBytes, bytesToJson, toArrayBuffer, bytesToBase64, base64ToBytes, base64ToArrayBuffer, basicAuth, SelectCase };
+export declare const publicUtils: Readonly<{
+    clone: typeof clone;
+    equal: typeof equal;
+    merge: typeof merge;
+    append: typeof append;
+    cover: typeof cover;
+    mergefn: typeof mergeFn;
+    appendfn: typeof appendFn;
+    coverfn: typeof coverFn;
+    contains: typeof contains;
+    random: typeof random;
+    either: typeof either;
+    SelectCase: typeof SelectCase;
+    convert: typeof convert;
+    clamp: typeof clamp;
+}>;

package/utils/object.d.ts

@@ -0,0 +1,16 @@
+type MergeMode = 'replace' | 'concat' | 'merge';
+export type MergeFilterFn = (key: string, value: unknown, depth: number, targetValue: unknown) => boolean;
+type MergeTuple<T extends readonly unknown[], S extends readonly unknown[]> = S extends readonly [infer Head, ...infer Rest] ? T extends readonly [infer Previous, ...infer Tail] ? [Merged<Previous, Head, 'merge'>, ...MergeTuple<Tail, Rest>] : [...S] : [...T];
+type Merged<T, S, Mode extends MergeMode> = S extends readonly unknown[] ? T extends readonly unknown[] ? Mode extends 'replace' ? [...S] : Mode extends 'concat' ? [...T, ...S] : number extends T['length'] | S['length'] ? (T[number] | S[number])[] : MergeTuple<T, S> : [...S] : S extends Record<string, unknown> ? Omit<T, keyof S> & {
+    [Key in keyof S]: Key extends keyof T ? Merged<T[Key], S[Key], Mode> : S[Key];
+} : S;
+export type MergeResult<T, Sources extends readonly unknown[], Mode extends MergeMode = 'merge'> = Sources extends readonly [infer Source, ...infer Rest] ? MergeResult<Merged<T, Source, Mode>, Rest, Mode> : T;
+export declare function clone<T>(source: T, deep?: boolean, proto?: boolean, map?: WeakMap<object, unknown>): T;
+export declare function equal(a: unknown, b: unknown): boolean;
+export declare function merge<T, Sources extends unknown[]>(target: T, ...sources: Sources): MergeResult<T, Sources>;
+export declare function append<T, Sources extends unknown[]>(target: T, ...sources: Sources): MergeResult<T, Sources, 'concat'>;
+export declare function cover<T, Sources extends unknown[]>(target: T, ...sources: Sources): MergeResult<T, Sources, 'replace'>;
+export declare function mergeFn<T, Sources extends unknown[]>(target: T, filter: MergeFilterFn | null, ...sources: Sources): MergeResult<T, Sources>;
+export declare function appendFn<T, Sources extends unknown[]>(target: T, filter: MergeFilterFn | null, ...sources: Sources): MergeResult<T, Sources, 'concat'>;
+export declare function coverFn<T, Sources extends unknown[]>(target: T, filter: MergeFilterFn | null, ...sources: Sources): MergeResult<T, Sources, 'replace'>;
+export {};

package/utils/selector.d.ts

@@ -0,0 +1,20 @@
+type Comparator = '<' | '<=' | '>' | '>=';
+type ResultValue<Input, Result, Meta> = Result | ((input: Input, meta: Meta) => Result);
+export declare class SelectCase<Input = unknown, Result = unknown, Meta = Record<string, unknown>> {
+    private readonly cases;
+    private defaultResult;
+    private valueType;
+    private allowMixedTypes;
+    case(condition: string | number | ((input: Input, meta: Meta) => boolean), result: ResultValue<Input, Result, Meta>): this;
+    casePredicate(fn: (input: Input, meta: Meta) => boolean, result: ResultValue<Input, Result, Meta>): this;
+    caseRange(min: number, max: number, result: ResultValue<Input, Result, Meta>): this;
+    caseIn(values: readonly (string | number)[], result: ResultValue<Input, Result, Meta>): this;
+    caseIncludes(values: string | readonly string[], result: ResultValue<Input, Result, Meta>): this;
+    caseRegex(regex: RegExp, result: ResultValue<Input, Result, Meta>): this;
+    caseCompare(operator: Comparator, value: number, result: ResultValue<Input, Result, Meta>): this;
+    else(result: ResultValue<Input, Result, Meta>): this;
+    match(input: Input, meta?: Meta): Result | null;
+    private resolve;
+    private validateType;
+}
+export {};

package/utils/string.d.ts

@@ -0,0 +1,8 @@
+export type ConvertMode = 'lower' | 'upper' | 'capitalize' | 'title' | 'camel' | 'pascal' | 'snake' | 'kebab' | 'constant';
+export declare function convert(value: string, mode?: ConvertMode, options?: {
+    delimiter?: string;
+    acronym?: boolean;
+}): string;
+export declare function escapeHtmlText(value: string): string;
+export declare function widgets(content: string): string;
+export declare function widgets(...contents: string[]): string[];