ahegao 1.69.46 → 1.69.48

package/dist/types/classes.d.ts

@@ -0,0 +1,214 @@
+import { FileInfo, RangedNumber } from "../structures/structs";
+export declare class TitleAndArtists {
+    readonly artists: string[];
+    readonly artist: string;
+    readonly title: string;
+    readonly sanitized_for_seed_artist: string;
+    readonly sanitized_for_seed_title: string;
+    readonly seed: string;
+    readonly hash: string;
+    constructor(artists: string[], artist: string, title: string);
+    get artistsDashTitle(): string;
+    findGeniusLyrics(): Promise<string | undefined>;
+}
+export declare namespace TitleAndArtists {
+    function fromFileInfo(fileInfo: FileInfo, aliases?: Aliases): Promise<TitleAndArtists>;
+}
+export declare class Aliases {
+    private reverseAliases;
+    add(name: string, ...aliases: string[]): Aliases;
+    get(name: string): string;
+}
+export declare const MUSIC_ARTIST_ALIASES: Aliases;
+export declare namespace Compare {
+    enum NumberCompareOperator {
+        Equal = "equal",
+        NotEqual = "not_equal",
+        GreaterThan = "greater_than",
+        GreaterThanOrEqual = "greater_than_or_equal",
+        LessThan = "less_than",
+        LessThanOrEqual = "less_than_or_equal"
+    }
+    enum StringCompareOperator {
+        Equal = "equal",
+        NotEqual = "not_equal",
+        Contains = "contains",
+        NotContains = "not_contains",
+        StartsWith = "starts_with",
+        EndsWith = "ends_with"
+    }
+    type Operator = NumberCompareOperator | StringCompareOperator;
+    function fromString(input: string): Operator;
+    function compare(value: number | string, operator: Operator): boolean;
+    function number(value: number, operator: NumberCompareOperator): boolean;
+    function string(value: string, operator: StringCompareOperator): boolean;
+}
+export declare class BoundedDeque<T> {
+    readonly maxSize: number;
+    private queue;
+    constructor(maxSize: number);
+    pushEnd(item: T): void;
+    pushFront(item: T): void;
+    popEnd(): T | undefined;
+    popFront(): T | undefined;
+    peekFront(): T | undefined;
+    peekEnd(): T | undefined;
+    get size(): number;
+    isEmpty(): boolean;
+    isFull(): boolean;
+    clear(): void;
+    toArray(): T[];
+    get array(): T[];
+    private trimFrontIfNeeded;
+    private trimBackIfNeeded;
+}
+export declare class Timer {
+    private _startMs;
+    private _lastIncrementMs;
+    private _count;
+    constructor();
+    reset(): void;
+    get startMs(): number;
+    get elapsedMs(): number;
+    get elapsedS(): number;
+    increment(incrementBy?: number, updateLoadingBar?: boolean): number;
+    get lastIncrementMs(): number;
+    get lastIncrementGapMs(): number;
+    get lastIncrementGapS(): number;
+    get count(): number;
+    get countPerSecond(): number;
+    get countPerSecondString(): string;
+    isFinished(goalCount: number): boolean;
+    getETASecondsForCount(goalCount: number): number;
+    getETASecondsForCountString(goalCount: number): string;
+    getCountAndPercentString(goalCount: number): string;
+    getFullStatsString(goalCount: number): string;
+    startLoadingBarForS(durationS: number, suffixDecider?: (() => string) | string, onFinish?: () => void, intervalMs?: number, rainbowIntervalMs?: number): NodeJS.Timeout;
+    updateLoadingBar: () => void;
+    startLoadingBarUntilDone(goalCountDecider: (() => number) | number, suffixDecider?: (() => string) | string, onFinish?: () => void, fullStats?: boolean, intervalMs?: number, rainbowIntervalMs?: number): NodeJS.Timeout;
+    startReplaceLastTerminalLineLoop(stringMaker: () => string, intervalMs?: number): NodeJS.Timeout;
+}
+export declare class NumberAnalysis {
+    private _lowest;
+    private _highest;
+    constructor(values?: Iterable<number>);
+    updateArray(buffer: Iterable<number>): void;
+    update(value: number): void;
+    get lowest(): number;
+    get highest(): number;
+    forEachLowestFirst(consumer: (value: number) => void): void;
+    forEachHighestFirst(consumer: (value: number) => void): void;
+    forEach(lowestFirst: boolean, consumer: (value: number) => void): void;
+    get gap(): number;
+    toRangedNumber(): RangedNumber;
+    toString(): string;
+}
+export declare class NumbersAnalysis extends NumberAnalysis {
+    private _sum;
+    readonly array: number[];
+    readonly map: Map<number, number>;
+    constructor(values?: Iterable<number>);
+    update(value: number): void;
+    get average(): number;
+    get sum(): number;
+    get count(): number;
+    sortedArray(ascending?: boolean): number[];
+    get median(): number;
+    getSortedFrequencyKeys(ascending?: boolean): number[];
+    toString(): string;
+}
+export declare class Lockable<T> {
+    private _locked;
+    private _item;
+    constructor(item: T);
+    get item(): T;
+    set item(item: T);
+    get locked(): boolean;
+    set locked(locked: boolean);
+    set(item: T): void;
+    get(): T;
+    lock(): void;
+    unlock(): void;
+    toString(): string;
+}
+export declare class Config {
+    readonly configPath: string;
+    private _init;
+    readonly name: string;
+    readonly basePath: string;
+    private readonly _config;
+    constructor(configPath?: string);
+    get isInit(): boolean;
+    throwIfNotInit(): void;
+    throwIfInit(error?: string): void;
+    define(key: string, value: number | string | boolean): Config;
+    get(key: string): number | string | boolean;
+    getString(key: string): string;
+    getNumber(key: string): number;
+    getBool(key: string): boolean;
+    is(key: string): boolean;
+    set(key: string, value: number | string | boolean): Config;
+    private _set;
+    init(): Config;
+    save(): Config;
+    toString(): string;
+}
+export declare class WeightedMap<T> {
+    private readonly _map;
+    private _totalWeight;
+    constructor();
+    add(item: T, weight?: number): WeightedMap<T>;
+    get(): T;
+    get empty(): boolean;
+    get hasItems(): boolean;
+    get size(): number;
+}
+export declare namespace WeightedMap {
+    function of<T>(input: T | T[]): WeightedMap<T>;
+}
+export type TextCompChild = TextCompObj | TextComp | string;
+export type TextCompChildren = TextCompChild | (TextCompChild)[] | WeightedMap<TextComp>;
+export type TextCompLookupMap = Map<string, WeightedMap<TextCompChild>>;
+export interface TextCompObj {
+    text?: string;
+    weight?: number;
+    chance?: number;
+    continueToChildOnFail?: boolean;
+    children?: TextCompChildren;
+}
+export declare class TextComp {
+    readonly text: string;
+    readonly chance: number;
+    readonly continueToChildOnFail: boolean;
+    private readonly _children;
+    constructor(data: TextCompObj);
+    get hasChildren(): boolean;
+    getRandomChild(): TextComp;
+    generate(lookup?: TextCompLookupMap, separator?: string, text?: string): string;
+    toString(): string;
+}
+export declare namespace TextComp {
+    function of(item: TextCompChild): TextComp;
+}
+export declare class Pair<L, R> {
+    left: L;
+    right: R;
+    constructor(left: L, right: R);
+    static of(L: any, R: any): Pair<any, any>;
+    swap(): Pair<R, L>;
+    asArray(): [L, R];
+    equals(other: Pair<L, R>): boolean;
+    toString(): string;
+}
+export declare class Maybe<T> {
+    readonly value: T | null;
+    readonly present: boolean;
+    constructor(value: T | null);
+    orElseGet(value: () => T): T;
+    orElse(value: T): T;
+}
+export declare namespace Maybe {
+    const EMPTY: Maybe<any>;
+    function fromArray<T>(valuesArray: T[], index: number): Maybe<T>;
+    function of<T>(value: T | null): Maybe<T>;
+}