ts-fsrs 2.0.2 → 2.1.1

package/{lib → dist}/fsrs.js

@@ -1,189 +1,203 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const seedrandom_1 = __importDefault(require("seedrandom"));
-const index_1 = require("./index");
-class FSRS {
-    constructor(param) {
-        this.repeat = (card, now) => {
-            card = Object.assign({}, card);
-            now = new Date(now.getTime());
-            card.elapsed_days = card.state === index_1.State.New ? 0 : now.diff(card.last_review, "days"); //相距时间
-            card.last_review = now; // 上次复习时间
-            card.reps += 1;
-            const s = new index_1.SchedulingCard(card);
-            s.update_state(card.state);
-            this.seed = String(card.last_review.getTime()) + String(card.elapsed_days);
-            let easy_interval, good_interval, hard_interval;
-            switch (card.state) {
-                case index_1.State.New:
-                    this.init_ds(s);
-                    s.again.due = now.scheduler(1);
-                    s.hard.due = now.scheduler(5);
-                    s.good.due = now.scheduler(10);
-                    easy_interval = this.next_interval(s.easy.stability * this.param.easy_bonus);
-                    s.easy.scheduled_days = easy_interval;
-                    s.easy.due = now.scheduler(easy_interval, true);
-                    break;
-                case index_1.State.Learning:
-                case index_1.State.Relearning:
-                    hard_interval = 0;
-                    good_interval = this.next_interval(s.good.stability);
-                    easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
-                    s.schedule(now, hard_interval, good_interval, easy_interval);
-                    break;
-                case index_1.State.Review:
-                    const interval = card.elapsed_days;
-                    const last_d = card.difficulty;
-                    const last_s = card.stability;
-                    const retrievability = this.current_retrievability(interval, last_s);
-                    this.next_ds(s, last_d, last_s, retrievability);
-                    hard_interval = this.next_interval(last_s * this.param.hard_factor);
-                    good_interval = this.next_interval(s.good.stability);
-                    hard_interval = Math.min(hard_interval, good_interval);
-                    good_interval = Math.max(good_interval, hard_interval + 1);
-                    easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
-                    s.schedule(now, hard_interval, good_interval, easy_interval);
-                    break;
-            }
-            return s.record_log(card, now);
-        };
-        this.get_retrievability = (card, now) => {
-            if (card.state !== index_1.State.Review) {
-                return undefined;
-            }
-            const t = Math.max(now.diff(card.last_review, "days"), 0);
-            return (this.current_retrievability(t, card.stability) * 100).toFixed(2) + '%';
-        };
-        this.param = param || (0, index_1.generatorParameters)();
-        this.intervalModifier = Math.log(this.param.request_retention) / Math.log(0.9);
-    }
-    init_ds(s) {
-        s.again.difficulty = this.init_difficulty(index_1.Rating.Again);
-        s.again.stability = this.init_stability(index_1.Rating.Again);
-        s.hard.difficulty = this.init_difficulty(index_1.Rating.Hard);
-        s.hard.stability = this.init_stability(index_1.Rating.Hard);
-        s.good.difficulty = this.init_difficulty(index_1.Rating.Good);
-        s.good.stability = this.init_stability(index_1.Rating.Good);
-        s.easy.difficulty = this.init_difficulty(index_1.Rating.Easy);
-        s.easy.stability = this.init_stability(index_1.Rating.Easy);
-    }
-    /**
-     *
-     * @param s scheduling Card
-     * @param last_d Difficulty
-     * @param last_s Stability
-     * @param retrievability Retrievability
-     */
-    next_ds(s, last_d, last_s, retrievability) {
-        s.again.difficulty = this.next_difficulty(last_d, index_1.Rating.Again);
-        s.again.stability = this.next_forget_stability(s.again.difficulty, last_s, retrievability);
-        s.hard.difficulty = this.next_difficulty(last_d, index_1.Rating.Hard);
-        s.hard.stability = this.next_recall_stability(s.hard.difficulty, last_s, retrievability);
-        s.good.difficulty = this.next_difficulty(last_d, index_1.Rating.Good);
-        s.good.stability = this.next_recall_stability(s.good.difficulty, last_s, retrievability);
-        s.easy.difficulty = this.next_difficulty(last_d, index_1.Rating.Easy);
-        s.easy.stability = this.next_recall_stability(s.easy.difficulty, last_s, retrievability);
-    }
-    /**
-     * The formula used is :
-     * $$S_0(G) = w_0 + G \cdot w_1$$
-     * $$\max \{S_0,0.1\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
-     * @return Stability (interval when R=90%)
-     */
-    init_stability(g) {
-        return Math.max(this.param.w[0] + this.param.w[1] * g, 0.1);
-    }
-    /**
-     * The formula used is :
-     * $$D_0(G) = w_2 + (G-2) \cdot w_3$$
-     * $$\min \{\max \{D_0(G),1\},10\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
-     * @return Difficulty D \in [1,10]
-     */
-    init_difficulty(g) {
-        return Math.min(Math.max(this.param.w[2] + this.param.w[3] * (g - 2), 1), 10);
-    }
-    apply_fuzz(ivl) {
-        if (!this.param.enable_fuzz || ivl < 2.5)
-            return ivl;
-        const generator = (0, seedrandom_1.default)(this.seed);
-        const fuzz_factor = generator();
-        ivl = Math.round(ivl);
-        const min_ivl = Math.max(2, Math.round(ivl * 0.95 - 1));
-        const max_ivl = Math.round(ivl * 1.05 + 1);
-        return Math.floor(fuzz_factor * (max_ivl - min_ivl + 1) + min_ivl);
-    }
-    next_interval(s) {
-        const newInterval = this.apply_fuzz(s * this.intervalModifier);
-        return Math.min(Math.max(Math.round(newInterval), 1), this.param.maximum_interval);
-    }
-    /**
-     * The formula used is :
-     * $$next_d = D + w_4 \cdot (R - 2)$$
-     * $$D^\prime(D,R) = w_5 \cdot D_0(2) +(1 - w_5) \cdot next_d$$
-     * @param d
-     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
-     * @return next_D
-     */
-    next_difficulty(d, g) {
-        const next_d = d + this.param.w[4] * (g - 2);
-        return this.constrain_difficulty(this.mean_reversion(this.param.w[2], next_d));
-    }
-    /**
-     * The formula used is :
-     * $$\min \{\max \{D_0,1\},10\}$$
-     */
-    constrain_difficulty(difficulty) {
-        return Math.min(Math.max(Number(difficulty.toFixed(2)), 1), 10);
-    }
-    /**
-     * The formula used is :
-     * $$w_5 \cdot init +(1 - w_5) \cdot current$$
-     * @param init $$w_2 : D_0(2) = w_2 + (R-2) \cdot w_3= w_2$$
-     * @param current $$D + w_4 \cdot (R - 2)$$
-     * @return difficulty
-     */
-    mean_reversion(init, current) {
-        return this.param.w[5] * init + (1 - this.param.w[5]) * current;
-    }
-    /**
-     * The formula used is :
-     * $$S^\prime_r(D,S,R) = S\cdot(e^{w_6}\cdot (11-D)\cdot S^{w_7}\cdot(e^{w_8\cdot(1-R)}-1)+1)$$
-     * @param d Difficulty D \in [1,10]
-     * @param s Stability (interval when R=90%)
-     * @param r Retrievability (probability of recall)
-     * @return S^\prime_r new stability after recall
-     */
-    next_recall_stability(d, s, r) {
-        return s * (1 + Math.exp(this.param.w[6]) *
-            (11 - d) *
-            Math.pow(s, this.param.w[7]) *
-            (Math.exp((1 - r) * this.param.w[8]) - 1));
-    }
-    /**
-     * The formula used is :
-     * $$S^\prime_f(D,S,R) = w_9\cdot D^{w_{10}}\cdot S^{w_{11}}\cdot e^{w_{12}\cdot(1-R)}.$$
-     * @param d Difficulty D \in [1,10]
-     * @param s Stability (interval when R=90%)
-     * @param r Retrievability (probability of recall)
-     * @return S^\prime_f new stability after forgetting
-     */
-    next_forget_stability(d, s, r) {
-        return this.param.w[9] * Math.pow(d, this.param.w[10]) * Math.pow(s, this.param.w[11]) * Math.exp((1 - r) * this.param.w[12]);
-    }
-    /**
-     * The formula used is :
-     * $$R(t,S) = 0.9^{\frac{t}{S}}$$
-     * @param t t days since the last review
-     * @param s Stability (interval when R=90%)
-     * @return r Retrievability (probability of recall)
-     */
-    current_retrievability(t, s) {
-        return Math.exp(Math.log(0.9) * t / s);
-    }
-}
-exports.default = FSRS;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const seedrandom_1 = __importDefault(require("seedrandom"));
+const index_1 = require("./index");
+const help_1 = require("./help");
+class FSRS {
+    param;
+    intervalModifier;
+    seed;
+    constructor(param) {
+        this.param = param || (0, index_1.generatorParameters)();
+        this.intervalModifier =
+            Math.log(this.param.request_retention) / Math.log(0.9);
+    }
+    repeat = (card, now) => {
+        card = {
+            ...card,
+        };
+        now = new Date((0, help_1.fixDate)(now));
+        card.elapsed_days =
+            card.state === index_1.State.New ? 0 : now.diff(card.last_review, "days"); //相距时间
+        card.last_review = now; // 上次复习时间
+        card.reps += 1;
+        const s = new index_1.SchedulingCard(card);
+        s.update_state(card.state);
+        this.seed = String(card.last_review.getTime()) + String(card.elapsed_days);
+        let easy_interval, good_interval, hard_interval;
+        switch (card.state) {
+            case index_1.State.New:
+                this.init_ds(s);
+                s.again.due = now.scheduler(1);
+                s.hard.due = now.scheduler(5);
+                s.good.due = now.scheduler(10);
+                easy_interval = this.next_interval(s.easy.stability * this.param.easy_bonus);
+                s.easy.scheduled_days = easy_interval;
+                s.easy.due = now.scheduler(easy_interval, true);
+                break;
+            case index_1.State.Learning:
+            case index_1.State.Relearning:
+                hard_interval = 0;
+                good_interval = this.next_interval(s.good.stability);
+                easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
+                s.schedule(now, hard_interval, good_interval, easy_interval);
+                break;
+            case index_1.State.Review: {
+                const interval = card.elapsed_days;
+                const last_d = card.difficulty;
+                const last_s = card.stability;
+                const retrievability = this.current_retrievability(interval, last_s);
+                this.next_ds(s, last_d, last_s, retrievability);
+                hard_interval = this.next_interval(last_s * this.param.hard_factor);
+                good_interval = this.next_interval(s.good.stability);
+                hard_interval = Math.min(hard_interval, good_interval);
+                good_interval = Math.max(good_interval, hard_interval + 1);
+                easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
+                s.schedule(now, hard_interval, good_interval, easy_interval);
+                break;
+            }
+        }
+        return s.record_log(card, now);
+    };
+    get_retrievability = (card, now) => {
+        if (card.state !== index_1.State.Review) {
+            return undefined;
+        }
+        const t = Math.max(now.diff(card.last_review, "days"), 0);
+        return ((this.current_retrievability(t, card.stability) * 100).toFixed(2) + "%");
+    };
+    init_ds(s) {
+        s.again.difficulty = this.init_difficulty(index_1.Rating.Again);
+        s.again.stability = this.init_stability(index_1.Rating.Again);
+        s.hard.difficulty = this.init_difficulty(index_1.Rating.Hard);
+        s.hard.stability = this.init_stability(index_1.Rating.Hard);
+        s.good.difficulty = this.init_difficulty(index_1.Rating.Good);
+        s.good.stability = this.init_stability(index_1.Rating.Good);
+        s.easy.difficulty = this.init_difficulty(index_1.Rating.Easy);
+        s.easy.stability = this.init_stability(index_1.Rating.Easy);
+    }
+    /**
+     *
+     * @param s scheduling Card
+     * @param last_d Difficulty
+     * @param last_s Stability
+     * @param retrievability Retrievability
+     */
+    next_ds(s, last_d, last_s, retrievability) {
+        s.again.difficulty = this.next_difficulty(last_d, index_1.Rating.Again);
+        s.again.stability = this.next_forget_stability(s.again.difficulty, last_s, retrievability);
+        s.hard.difficulty = this.next_difficulty(last_d, index_1.Rating.Hard);
+        s.hard.stability = this.next_recall_stability(s.hard.difficulty, last_s, retrievability);
+        s.good.difficulty = this.next_difficulty(last_d, index_1.Rating.Good);
+        s.good.stability = this.next_recall_stability(s.good.difficulty, last_s, retrievability);
+        s.easy.difficulty = this.next_difficulty(last_d, index_1.Rating.Easy);
+        s.easy.stability = this.next_recall_stability(s.easy.difficulty, last_s, retrievability);
+    }
+    /**
+     * The formula used is :
+     * $$S_0(G) = w_0 + G \cdot w_1$$
+     * $$\max \{S_0,0.1\}$$
+     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * @return Stability (interval when R=90%)
+     */
+    init_stability(g) {
+        return Math.max(this.param.w[0] + this.param.w[1] * g, 0.1);
+    }
+    /**
+     * The formula used is :
+     * $$D_0(G) = w_2 + (G-2) \cdot w_3$$
+     * $$\min \{\max \{D_0(G),1\},10\}$$
+     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * @return Difficulty D \in [1,10]
+     */
+    init_difficulty(g) {
+        return Math.min(Math.max(this.param.w[2] + this.param.w[3] * (g - 2), 1), 10);
+    }
+    apply_fuzz(ivl) {
+        if (!this.param.enable_fuzz || ivl < 2.5)
+            return ivl;
+        const generator = (0, seedrandom_1.default)(this.seed);
+        const fuzz_factor = generator();
+        ivl = Math.round(ivl);
+        const min_ivl = Math.max(2, Math.round(ivl * 0.95 - 1));
+        const max_ivl = Math.round(ivl * 1.05 + 1);
+        return Math.floor(fuzz_factor * (max_ivl - min_ivl + 1) + min_ivl);
+    }
+    next_interval(s) {
+        const newInterval = this.apply_fuzz(s * this.intervalModifier);
+        return Math.min(Math.max(Math.round(newInterval), 1), this.param.maximum_interval);
+    }
+    /**
+     * The formula used is :
+     * $$next_d = D + w_4 \cdot (R - 2)$$
+     * $$D^\prime(D,R) = w_5 \cdot D_0(2) +(1 - w_5) \cdot next_d$$
+     * @param d
+     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
+     * @return next_D
+     */
+    next_difficulty(d, g) {
+        const next_d = d + this.param.w[4] * (g - 2);
+        return this.constrain_difficulty(this.mean_reversion(this.param.w[2], next_d));
+    }
+    /**
+     * The formula used is :
+     * $$\min \{\max \{D_0,1\},10\}$$
+     */
+    constrain_difficulty(difficulty) {
+        return Math.min(Math.max(Number(difficulty.toFixed(2)), 1), 10);
+    }
+    /**
+     * The formula used is :
+     * $$w_5 \cdot init +(1 - w_5) \cdot current$$
+     * @param init $$w_2 : D_0(2) = w_2 + (R-2) \cdot w_3= w_2$$
+     * @param current $$D + w_4 \cdot (R - 2)$$
+     * @return difficulty
+     */
+    mean_reversion(init, current) {
+        return this.param.w[5] * init + (1 - this.param.w[5]) * current;
+    }
+    /**
+     * The formula used is :
+     * $$S^\prime_r(D,S,R) = S\cdot(e^{w_6}\cdot (11-D)\cdot S^{w_7}\cdot(e^{w_8\cdot(1-R)}-1)+1)$$
+     * @param d Difficulty D \in [1,10]
+     * @param s Stability (interval when R=90%)
+     * @param r Retrievability (probability of recall)
+     * @return S^\prime_r new stability after recall
+     */
+    next_recall_stability(d, s, r) {
+        return (s *
+            (1 +
+                Math.exp(this.param.w[6]) *
+                    (11 - d) *
+                    Math.pow(s, this.param.w[7]) *
+                    (Math.exp((1 - r) * this.param.w[8]) - 1)));
+    }
+    /**
+     * The formula used is :
+     * $$S^\prime_f(D,S,R) = w_9\cdot D^{w_{10}}\cdot S^{w_{11}}\cdot e^{w_{12}\cdot(1-R)}.$$
+     * @param d Difficulty D \in [1,10]
+     * @param s Stability (interval when R=90%)
+     * @param r Retrievability (probability of recall)
+     * @return S^\prime_f new stability after forgetting
+     */
+    next_forget_stability(d, s, r) {
+        return (this.param.w[9] *
+            Math.pow(d, this.param.w[10]) *
+            Math.pow(s, this.param.w[11]) *
+            Math.exp((1 - r) * this.param.w[12]));
+    }
+    /**
+     * The formula used is :
+     * $$R(t,S) = 0.9^{\frac{t}{S}}$$
+     * @param t t days since the last review
+     * @param s Stability (interval when R=90%)
+     * @return r Retrievability (probability of recall)
+     */
+    current_retrievability(t, s) {
+        return Math.exp((Math.log(0.9) * t) / s);
+    }
+}
+exports.default = FSRS;

package/dist/fsrs_version.d.ts

@@ -0,0 +1,2 @@
+declare const FSRSVersion: string;
+export default FSRSVersion;

package/dist/fsrs_version.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const package_json_1 = require("../../package.json");
+const FSRSVersion = package_json_1.version;
+exports.default = FSRSVersion;

package/{lib → dist}/help.d.ts

@@ -1,19 +1,20 @@
-export type unit = 'days' | 'minutes';
-export type int = number & {
-    __int__: void;
-};
-export type double = number & {
-    __double__: void;
-};
-declare global {
-    export interface Date {
-        scheduler(t: int, isDay?: boolean): Date;
-        diff(pre: Date, unit: unit): int;
-        format(): string;
-        dueFormat(last_review: Date, unit?: boolean): string;
-    }
-}
-export declare function date_scheduler(now: Date, t: number, isDay?: boolean): Date;
-export declare function date_diff(now: Date, pre: Date, unit: unit): number;
-export declare function formatDate(date: Date): string;
-export declare function show_diff_message(due: Date, last_review: Date, unit?: boolean): string;
+export type unit = "days" | "minutes";
+export type int = number & {
+    __int__: void;
+};
+export type double = number & {
+    __double__: void;
+};
+declare global {
+    export interface Date {
+        scheduler(t: int, isDay?: boolean): Date;
+        diff(pre: Date, unit: unit): int;
+        format(): string;
+        dueFormat(last_review: Date, unit?: boolean): string;
+    }
+}
+export declare function date_scheduler(now: Date, t: number, isDay?: boolean): Date;
+export declare function date_diff(now: Date, pre: Date, unit: unit): number;
+export declare function formatDate(date: Date): string;
+export declare function show_diff_message(due: Date, last_review: Date, unit?: boolean, timeUnit?: string[]): string;
+export declare function fixDate(value: unknown): Date;

package/dist/help.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixDate = exports.show_diff_message = exports.formatDate = exports.date_diff = exports.date_scheduler = void 0;
+Date.prototype.scheduler = function (t, isDay) {
+    return date_scheduler(this, t, isDay);
+};
+/**
+ * 当前时间与之前的时间差值
+ * @param pre 比当前时间还要之前
+ * @param unit 单位: days | minutes
+ */
+Date.prototype.diff = function (pre, unit) {
+    return date_diff(this, pre, unit);
+};
+Date.prototype.format = function () {
+    return formatDate(this);
+};
+Date.prototype.dueFormat = function (last_review, unit) {
+    return show_diff_message(this, last_review, unit);
+};
+function date_scheduler(now, t, isDay) {
+    return new Date(isDay
+        ? now.getTime() + t * 24 * 60 * 60 * 1000
+        : now.getTime() + t * 60 * 1000);
+}
+exports.date_scheduler = date_scheduler;
+function date_diff(now, pre, unit) {
+    const diff = now.getTime() - pre.getTime();
+    let r = 0;
+    switch (unit) {
+        case "days":
+            r = Math.floor(diff / (24 * 60 * 60 * 1000));
+            break;
+        case "minutes":
+            r = Math.floor(diff / (60 * 1000));
+            break;
+    }
+    return r;
+}
+exports.date_diff = date_diff;
+function formatDate(date) {
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const seconds = date.getSeconds();
+    return `${year}-${padZero(month)}-${padZero(day)} ${padZero(hours)}:${padZero(minutes)}:${padZero(seconds)}`;
+}
+exports.formatDate = formatDate;
+function padZero(num) {
+    return num < 10 ? `0${num}` : `${num}`;
+}
+const TIMEUNIT = [60, 60, 24, 31, 12];
+const TIMEUNITFORMAT = ["second", "min", "hour", "day", "month", "year"];
+function show_diff_message(due, last_review, unit, timeUnit = TIMEUNITFORMAT) {
+    due = fixDate(due);
+    last_review = fixDate(last_review);
+    if (timeUnit.length !== TIMEUNITFORMAT.length) {
+        timeUnit = TIMEUNITFORMAT;
+    }
+    let diff = due.getTime() - last_review.getTime();
+    let i;
+    diff /= 1000;
+    for (i = 0; i < TIMEUNIT.length; i++) {
+        if (diff < TIMEUNIT[i]) {
+            break;
+        }
+        else {
+            diff /= TIMEUNIT[i];
+        }
+    }
+    return `${Math.floor(diff)}${unit ? timeUnit[i] : ""}`;
+}
+exports.show_diff_message = show_diff_message;
+function fixDate(value) {
+    if (typeof value === "object" && value instanceof Date) {
+        return value;
+    }
+    else if (typeof value === "string") {
+        const timestamp = Date.parse(value);
+        if (!isNaN(timestamp)) {
+            return new Date(timestamp);
+        }
+        else {
+            throw new Error(`Invalid date:[${value}]`);
+        }
+    }
+    else if (typeof value === "number") {
+        return new Date(value);
+    }
+    throw new Error(`Invalid date:[${value}]`);
+}
+exports.fixDate = fixDate;

package/{lib → dist}/index.d.ts

@@ -1,25 +1,26 @@
-import FSRS from "./fsrs";
-import { Card, default_easy_bonus, default_enable_fuzz, default_hard_factor, default_maximum_interval, default_request_retention, default_w, FSRSParameters, Rating, RatingType, ReviewLog, SchedulingLog, State, StateType } from "./models";
-import { SchedulingCard } from "./scheduler";
-declare const fsrs: (param?: FSRSParameters) => FSRS;
-declare const createEmptyCard: (now?: Date) => Card;
-declare const generatorParameters: (props?: {
-    request_retention?: number;
-    maximum_interval?: number;
-    easy_bonus?: number;
-    hard_factor?: number;
-    w?: number[];
-    enable_fuzz?: boolean;
-}) => {
-    request_retention: number;
-    maximum_interval: number;
-    easy_bonus: number;
-    hard_factor: number;
-    w: number[];
-    enable_fuzz: boolean;
-};
-declare const FSRS_Version = "2.0.2";
-export { fsrs, FSRS_Version, State, Rating, SchedulingCard, createEmptyCard, generatorParameters };
-export type { StateType, RatingType, ReviewLog, Card, SchedulingLog, FSRSParameters };
-export { default_request_retention, default_maximum_interval, default_easy_bonus, default_hard_factor, default_w, default_enable_fuzz };
-export { date_scheduler, date_diff, formatDate, show_diff_message } from './help';
+import FSRS from "./fsrs";
+import { Card, default_easy_bonus, default_enable_fuzz, default_hard_factor, default_maximum_interval, default_request_retention, default_w, FSRSParameters, Rating, RatingType, ReviewLog, SchedulingLog, State, StateType } from "./models";
+import { SchedulingCard } from "./scheduler";
+import FSRSVersion from "./fsrs_version";
+declare const fsrs: (param?: FSRSParameters) => FSRS;
+declare const createEmptyCard: (now?: Date) => Card;
+declare const generatorParameters: (props?: {
+    request_retention?: number;
+    maximum_interval?: number;
+    easy_bonus?: number;
+    hard_factor?: number;
+    w?: number[];
+    enable_fuzz?: boolean;
+}) => {
+    request_retention: number;
+    maximum_interval: number;
+    easy_bonus: number;
+    hard_factor: number;
+    w: number[];
+    enable_fuzz: boolean;
+};
+export { fsrs, FSRSVersion, State, Rating, SchedulingCard, createEmptyCard, generatorParameters, };
+export type { StateType, RatingType, ReviewLog, Card, SchedulingLog, FSRSParameters, };
+export { default_request_retention, default_maximum_interval, default_easy_bonus, default_hard_factor, default_w, default_enable_fuzz, };
+export { date_scheduler, date_diff, formatDate, show_diff_message, } from "./help";
+export type { int, double } from "./help";