course-format-ts 1.0.0

package/.idea/edu-format-ts.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/edu-format" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,28 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N806" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyStringConversionWithoutDunderMethodInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="reportedTypes">
+        <list>
+          <option value="types.FunctionType" />
+          <option value="type" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="PySide2.QtCore.QAbstractItemModel.*" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

package/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KubernetesApiProvider">{}</component>
+</project>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/edu-format-ts.iml" filepath="$PROJECT_DIR$/.idea/edu-format-ts.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

package/AGENTS.md

@@ -0,0 +1 @@
+This library is a ts version for JetBrains Academy format.

package/dist/courseFormat/AnswerPlaceholder.d.ts

@@ -0,0 +1,37 @@
+import { CheckStatus } from "./CheckStatus";
+import { TaskFile } from "./TaskFile";
+import { AnswerPlaceholderDependency } from "./AnswerPlaceholderDependency";
+export declare class AnswerPlaceholder {
+    offset: number;
+    length: number;
+    index: number;
+    private _initialState?;
+    private _taskFile?;
+    placeholderDependency?: AnswerPlaceholderDependency;
+    isInitializedFromDependency: boolean;
+    possibleAnswer: string;
+    placeholderText: string;
+    selected: boolean;
+    status: CheckStatus;
+    isVisible: boolean;
+    studentAnswer?: string;
+    constructor();
+    constructor(offset: number, placeholderText: string);
+    get initialState(): MyInitialState;
+    set initialState(value: MyInitialState);
+    get taskFile(): TaskFile;
+    set taskFile(value: TaskFile);
+    init(file: TaskFile, isRestarted: boolean): void;
+    reset(revertStartOffset: boolean): void;
+    initEmpty(): void;
+    get isCurrentlyVisible(): boolean;
+    get shouldBeVisible(): boolean;
+    isValid(textLength: number): boolean;
+    get endOffset(): number;
+    toString(): string;
+}
+export declare class MyInitialState {
+    length: number;
+    offset: number;
+    constructor(initialOffset?: number, initialLength?: number);
+}

package/dist/courseFormat/AnswerPlaceholder.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyInitialState = exports.AnswerPlaceholder = void 0;
+const CheckStatus_1 = require("./CheckStatus");
+class AnswerPlaceholder {
+    constructor(offset, placeholderText) {
+        this.offset = -1;
+        this.length = -1;
+        this.index = -1;
+        this.isInitializedFromDependency = false;
+        this.possibleAnswer = "";
+        this.placeholderText = "";
+        this.selected = false;
+        this.status = CheckStatus_1.CheckStatus.Unchecked;
+        this.isVisible = true;
+        if (offset !== undefined && placeholderText !== undefined) {
+            this.offset = offset;
+            this.length = placeholderText.length;
+            this.placeholderText = placeholderText;
+        }
+    }
+    get initialState() {
+        if (!this._initialState) {
+            throw new Error("No initial state for answer placeholder");
+        }
+        return this._initialState;
+    }
+    set initialState(value) {
+        this._initialState = value;
+    }
+    get taskFile() {
+        if (!this._taskFile) {
+            throw new Error(`Task file is null for answer placeholder`);
+        }
+        return this._taskFile;
+    }
+    set taskFile(value) {
+        this._taskFile = value;
+    }
+    init(file, isRestarted) {
+        this.taskFile = file;
+        if (isRestarted)
+            return;
+        if (this.placeholderDependency) {
+            this.placeholderDependency.answerPlaceholder = this;
+        }
+        this.initialState = new MyInitialState(this.offset, this.length);
+        this.status = file.task.status;
+    }
+    reset(revertStartOffset) {
+        if (revertStartOffset) {
+            this.offset = this.initialState.offset;
+        }
+        this.length = this.initialState.length;
+        this.status = CheckStatus_1.CheckStatus.Unchecked;
+        this.isInitializedFromDependency = false;
+    }
+    initEmpty() {
+        this.initialState = new MyInitialState(this.offset, this.placeholderText.length);
+    }
+    get isCurrentlyVisible() {
+        let result = this.shouldBeVisible;
+        if (this.placeholderDependency) {
+            result = result || !this.isInitializedFromDependency;
+        }
+        return result;
+    }
+    get shouldBeVisible() {
+        if (!this.placeholderDependency) {
+            return this.isVisible;
+        }
+        return this.isVisible && this.placeholderDependency.isVisible;
+    }
+    isValid(textLength) {
+        return this.offset >= 0 && this.length >= 0 && this.endOffset <= textLength;
+    }
+    get endOffset() {
+        return this.offset + this.length;
+    }
+    toString() {
+        const task = this.taskFile.task;
+        const lesson = task.lesson;
+        const section = lesson.section;
+        const sectionPrefix = section ? `${section.name}#` : "";
+        return `${sectionPrefix}${lesson.name}#${task.name}#${this.taskFile.name}[${this.offset}, ${this.endOffset}]`;
+    }
+}
+exports.AnswerPlaceholder = AnswerPlaceholder;
+class MyInitialState {
+    constructor(initialOffset, initialLength) {
+        this.length = -1;
+        this.offset = -1;
+        if (initialOffset !== undefined) {
+            this.offset = initialOffset;
+        }
+        if (initialLength !== undefined) {
+            this.length = initialLength;
+        }
+    }
+}
+exports.MyInitialState = MyInitialState;

package/dist/courseFormat/AnswerPlaceholderComparator.d.ts

@@ -0,0 +1,4 @@
+import { AnswerPlaceholder } from "./AnswerPlaceholder";
+export declare const AnswerPlaceholderComparator: {
+    compare(a: AnswerPlaceholder, b: AnswerPlaceholder): number;
+};

package/dist/courseFormat/AnswerPlaceholderComparator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnswerPlaceholderComparator = void 0;
+exports.AnswerPlaceholderComparator = {
+    compare(a, b) {
+        return a.offset - b.offset;
+    },
+};

package/dist/courseFormat/AnswerPlaceholderDependency.d.ts

@@ -0,0 +1,19 @@
+import { AnswerPlaceholder } from "./AnswerPlaceholder";
+import { Course } from "./Course";
+export declare class AnswerPlaceholderDependency {
+    sectionName?: string;
+    lessonName: string;
+    taskName: string;
+    fileName: string;
+    placeholderIndex: number;
+    isVisible: boolean;
+    answerPlaceholder: AnswerPlaceholder;
+    constructor(answerPlaceholder?: AnswerPlaceholder, sectionName?: string | null, lessonName?: string, taskName?: string, fileName?: string, placeholderIndex?: number, isVisible?: boolean);
+    resolve(course: Course): AnswerPlaceholder | undefined;
+    toString(): string;
+    static create(answerPlaceholder: AnswerPlaceholder, text: string): AnswerPlaceholderDependency | null;
+}
+export declare class InvalidDependencyException extends Error {
+    readonly customMessage: string;
+    constructor(dependencyText: string, customMessage?: string);
+}

package/dist/courseFormat/AnswerPlaceholderDependency.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidDependencyException = exports.AnswerPlaceholderDependency = void 0;
+const uiMessages_1 = require("./uiMessages");
+const DEPENDENCY_PATTERN = /(([^#]+)#)?([^#]+)#([^#]+)#([^#]+)#(\d+)/;
+class AnswerPlaceholderDependency {
+    constructor(answerPlaceholder, sectionName, lessonName = "", taskName = "", fileName = "", placeholderIndex = 0, isVisible = true) {
+        this.lessonName = "";
+        this.taskName = "";
+        this.fileName = "";
+        this.placeholderIndex = 0;
+        this.isVisible = true;
+        if (answerPlaceholder) {
+            this.answerPlaceholder = answerPlaceholder;
+        }
+        this.sectionName = sectionName !== null && sectionName !== void 0 ? sectionName : undefined;
+        this.lessonName = lessonName;
+        this.taskName = taskName;
+        this.fileName = fileName;
+        this.placeholderIndex = placeholderIndex;
+        this.isVisible = isVisible;
+    }
+    resolve(course) {
+        const lesson = course.getLesson(this.sectionName, this.lessonName);
+        const task = lesson === null || lesson === void 0 ? void 0 : lesson.getTask(this.taskName);
+        const taskFile = task === null || task === void 0 ? void 0 : task.getTaskFile(this.fileName);
+        return taskFile === null || taskFile === void 0 ? void 0 : taskFile.answerPlaceholders[this.placeholderIndex];
+    }
+    toString() {
+        const section = this.sectionName ? `${this.sectionName}#` : "";
+        return `${section}${this.lessonName}#${this.taskName}#${this.fileName}#${this.placeholderIndex + 1}`;
+    }
+    static create(answerPlaceholder, text) {
+        if (!text.trim()) {
+            return null;
+        }
+        const task = answerPlaceholder.taskFile.task;
+        const match = text.match(DEPENDENCY_PATTERN);
+        if (!match) {
+            throw new InvalidDependencyException(text);
+        }
+        const sectionName = match[2];
+        const lessonName = match[3];
+        const taskName = match[4];
+        const filePath = toSystemIndependent(match[5]);
+        const placeholderIndex = Number.parseInt(match[6], 10) - 1;
+        if (Number.isNaN(placeholderIndex)) {
+            throw new InvalidDependencyException(text);
+        }
+        const dependency = new AnswerPlaceholderDependency(answerPlaceholder, sectionName, lessonName, taskName, filePath, placeholderIndex, true);
+        const targetPlaceholder = dependency.resolve(task.course);
+        if (!targetPlaceholder) {
+            throw new InvalidDependencyException(text, (0, uiMessages_1.message)("exception.placeholder.non.existing"));
+        }
+        if (targetPlaceholder.taskFile.task === task) {
+            throw new InvalidDependencyException(text, (0, uiMessages_1.message)("exception.placeholder.wrong.reference.to.source"));
+        }
+        if (refersToNextTask(task, targetPlaceholder.taskFile.task)) {
+            throw new InvalidDependencyException(text, (0, uiMessages_1.message)("exception.placeholder.wrong.reference.to.next"));
+        }
+        return dependency;
+    }
+}
+exports.AnswerPlaceholderDependency = AnswerPlaceholderDependency;
+class InvalidDependencyException extends Error {
+    constructor(dependencyText, customMessage) {
+        super(customMessage
+            ? `'${dependencyText}' is not a valid placeholder dependency\n${customMessage}`
+            : `'${dependencyText}' is not a valid placeholder dependency`);
+        this.customMessage = customMessage !== null && customMessage !== void 0 ? customMessage : (0, uiMessages_1.message)("exception.placeholder.invalid.dependency");
+    }
+}
+exports.InvalidDependencyException = InvalidDependencyException;
+function toSystemIndependent(pathValue) {
+    return pathValue.replace(/\\/g, "/");
+}
+function refersToNextTask(sourceTask, targetTask) {
+    const sourceLesson = sourceTask.lesson;
+    const targetLesson = targetTask.lesson;
+    if (sourceLesson === targetLesson) {
+        return targetTask.index > sourceTask.index;
+    }
+    if (sourceLesson.section === targetLesson.section) {
+        return targetLesson.index > sourceLesson.index;
+    }
+    return getIndexInCourse(targetLesson) > getIndexInCourse(sourceLesson);
+}
+function getIndexInCourse(lesson) {
+    var _a, _b;
+    return (_b = (_a = lesson.section) === null || _a === void 0 ? void 0 : _a.index) !== null && _b !== void 0 ? _b : lesson.index;
+}

package/dist/courseFormat/CheckFeedback.d.ts

@@ -0,0 +1,20 @@
+import { CheckResult } from "./CheckResult";
+import { CheckStatus } from "./CheckStatus";
+import { EduTestInfo } from "./EduTestInfo";
+export declare class CheckFeedback {
+    readonly failedTestInfo?: EduTestInfo;
+    readonly time?: Date;
+    private _message;
+    private _expected?;
+    private _actual?;
+    constructor(failedTestInfo?: EduTestInfo | null, time?: Date | null);
+    static fromMessage(message: string, time?: Date | null, expected?: string | null, actual?: string | null): CheckFeedback;
+    static fromCheckResult(time: Date, checkResult: CheckResult): CheckFeedback;
+    get message(): string;
+    set message(value: string);
+    get expected(): string | undefined;
+    set expected(value: string | undefined);
+    get actual(): string | undefined;
+    set actual(value: string | undefined);
+    toCheckResult(status: CheckStatus): CheckResult;
+}

package/dist/courseFormat/CheckFeedback.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckFeedback = void 0;
+const CheckResult_1 = require("./CheckResult");
+const loggerUtils_1 = require("./loggerUtils");
+class CheckFeedback {
+    constructor(failedTestInfo, time) {
+        this._message = "";
+        this.failedTestInfo = failedTestInfo !== null && failedTestInfo !== void 0 ? failedTestInfo : undefined;
+        this.time = time !== null && time !== void 0 ? time : undefined;
+    }
+    static fromMessage(message, time, expected, actual) {
+        const feedback = new CheckFeedback(undefined, time !== null && time !== void 0 ? time : undefined);
+        feedback.message = message;
+        feedback.expected = expected !== null && expected !== void 0 ? expected : undefined;
+        feedback.actual = actual !== null && actual !== void 0 ? actual : undefined;
+        return feedback;
+    }
+    static fromCheckResult(time, checkResult) {
+        var _a, _b;
+        const feedback = new CheckFeedback(checkResult.executedTestsInfo[0], time);
+        feedback.expected = (_a = checkResult.diffResolved) === null || _a === void 0 ? void 0 : _a.expected;
+        feedback.actual = (_b = checkResult.diffResolved) === null || _b === void 0 ? void 0 : _b.actual;
+        feedback.message = checkResult.messageResolved;
+        return feedback;
+    }
+    get message() {
+        var _a;
+        return this._message || ((_a = this.failedTestInfo) === null || _a === void 0 ? void 0 : _a.message) || "";
+    }
+    set message(value) {
+        this._message = value;
+    }
+    get expected() {
+        var _a, _b, _c;
+        return (_a = this._expected) !== null && _a !== void 0 ? _a : (_c = (_b = this.failedTestInfo) === null || _b === void 0 ? void 0 : _b.checkResultDiff) === null || _c === void 0 ? void 0 : _c.expected;
+    }
+    set expected(value) {
+        this._expected = value;
+    }
+    get actual() {
+        var _a, _b, _c;
+        return (_a = this._actual) !== null && _a !== void 0 ? _a : (_c = (_b = this.failedTestInfo) === null || _b === void 0 ? void 0 : _b.checkResultDiff) === null || _c === void 0 ? void 0 : _c.actual;
+    }
+    set actual(value) {
+        this._actual = value;
+    }
+    toCheckResult(status) {
+        const expected = this.expected;
+        const actual = this.actual;
+        if ((expected === undefined && actual !== undefined) || (expected !== undefined && actual === undefined)) {
+            (0, loggerUtils_1.logger)("CheckFeedback").warn("Expected/Actual: one value is missing. Second value would be ignored");
+        }
+        const diff = expected !== undefined && actual !== undefined ? new CheckResult_1.CheckResultDiff(expected, actual) : undefined;
+        return new CheckResult_1.CheckResult(status, this.message, undefined, diff);
+    }
+}
+exports.CheckFeedback = CheckFeedback;

package/dist/courseFormat/CheckResult.d.ts

@@ -0,0 +1,33 @@
+import { CheckResultSeverity } from "./CheckResultSeverity";
+import { CheckStatus } from "./CheckStatus";
+import { EduTestInfo } from "./EduTestInfo";
+export declare class CheckResult {
+    readonly status: CheckStatus;
+    readonly severity: CheckResultSeverity;
+    readonly hyperlinkAction?: () => void;
+    readonly executedTestsInfo: EduTestInfo[];
+    private readonly firstFailedTest?;
+    details?: string;
+    diff?: CheckResultDiff;
+    messageText: string;
+    constructor(status: CheckStatus, messageText?: string, details?: string | null, diff?: CheckResultDiff | null, severity?: CheckResultSeverity, hyperlinkAction?: (() => void) | null, executedTestsInfo?: EduTestInfo[]);
+    get fullMessage(): string;
+    get isSolved(): boolean;
+    get detailsResolved(): string | undefined;
+    get diffResolved(): CheckResultDiff | undefined;
+    get messageResolved(): string;
+    static NO_LOCAL_CHECK: CheckResult;
+    static LOGIN_NEEDED: CheckResult;
+    static CONNECTION_FAILED: CheckResult;
+    static SOLVED: CheckResult;
+    static CANCELED: CheckResult;
+    static UNCHECKED: CheckResult;
+    static get noTestsRun(): CheckResult;
+    static get failedToCheck(): CheckResult;
+}
+export declare class CheckResultDiff {
+    readonly expected: string;
+    readonly actual: string;
+    readonly title: string;
+    constructor(expected: string, actual: string, title?: string);
+}

package/dist/courseFormat/CheckResult.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckResultDiff = exports.CheckResult = void 0;
+const CheckResultSeverity_1 = require("./CheckResultSeverity");
+const CheckStatus_1 = require("./CheckStatus");
+const EduFormatNames_1 = require("./EduFormatNames");
+const uiMessages_1 = require("./uiMessages");
+class CheckResult {
+    constructor(status, messageText = "", details, diff, severity = CheckResultSeverity_1.CheckResultSeverity.Info, hyperlinkAction, executedTestsInfo = []) {
+        this.status = status;
+        this.severity = severity;
+        this.hyperlinkAction = hyperlinkAction !== null && hyperlinkAction !== void 0 ? hyperlinkAction : undefined;
+        this.executedTestsInfo = executedTestsInfo;
+        this.firstFailedTest = this.executedTestsInfo.find((test) => !test.isSuccess);
+        this.details = details !== null && details !== void 0 ? details : undefined;
+        this.diff = diff !== null && diff !== void 0 ? diff : undefined;
+        this.messageText = messageText;
+    }
+    get fullMessage() {
+        return this.details ? `${this.messageText}\n\n${this.details}` : this.messageText;
+    }
+    get isSolved() {
+        return this.status === CheckStatus_1.CheckStatus.Solved;
+    }
+    get detailsResolved() {
+        var _a, _b;
+        return (_a = this.details) !== null && _a !== void 0 ? _a : (_b = this.firstFailedTest) === null || _b === void 0 ? void 0 : _b.details;
+    }
+    get diffResolved() {
+        var _a, _b;
+        return (_a = this.diff) !== null && _a !== void 0 ? _a : (_b = this.firstFailedTest) === null || _b === void 0 ? void 0 : _b.checkResultDiff;
+    }
+    get messageResolved() {
+        var _a;
+        return this.messageText || ((_a = this.firstFailedTest) === null || _a === void 0 ? void 0 : _a.message) || "";
+    }
+    static get noTestsRun() {
+        return new CheckResult(CheckStatus_1.CheckStatus.Unchecked, (0, uiMessages_1.message)("check.no.tests.with.help.guide", EduFormatNames_1.NO_TESTS_URL));
+    }
+    static get failedToCheck() {
+        return new CheckResult(CheckStatus_1.CheckStatus.Unchecked, (0, uiMessages_1.message)("error.failed.to.launch.checking.with.help.guide", EduFormatNames_1.FAILED_TO_CHECK_URL));
+    }
+}
+exports.CheckResult = CheckResult;
+CheckResult.NO_LOCAL_CHECK = new CheckResult(CheckStatus_1.CheckStatus.Unchecked, (0, uiMessages_1.message)("check.result.local.check.unavailable"));
+CheckResult.LOGIN_NEEDED = new CheckResult(CheckStatus_1.CheckStatus.Unchecked, EduFormatNames_1.LOGIN_NEEDED_MESSAGE);
+CheckResult.CONNECTION_FAILED = new CheckResult(CheckStatus_1.CheckStatus.Unchecked, (0, uiMessages_1.message)("check.result.connection.failed"));
+CheckResult.SOLVED = new CheckResult(CheckStatus_1.CheckStatus.Solved);
+CheckResult.CANCELED = new CheckResult(CheckStatus_1.CheckStatus.Unchecked, (0, uiMessages_1.message)("check.result.canceled"));
+CheckResult.UNCHECKED = new CheckResult(CheckStatus_1.CheckStatus.Unchecked);
+class CheckResultDiff {
+    constructor(expected, actual, title = "") {
+        this.expected = expected;
+        this.actual = actual;
+        this.title = title;
+    }
+}
+exports.CheckResultDiff = CheckResultDiff;

package/dist/courseFormat/CheckResultSeverity.d.ts

@@ -0,0 +1,7 @@
+export declare enum CheckResultSeverity {
+    Info = "Info",
+    Warning = "Warning",
+    Error = "Error"
+}
+export declare function isWarning(severity: CheckResultSeverity): boolean;
+export declare function isInfo(severity: CheckResultSeverity): boolean;

package/dist/courseFormat/CheckResultSeverity.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckResultSeverity = void 0;
+exports.isWarning = isWarning;
+exports.isInfo = isInfo;
+var CheckResultSeverity;
+(function (CheckResultSeverity) {
+    CheckResultSeverity["Info"] = "Info";
+    CheckResultSeverity["Warning"] = "Warning";
+    CheckResultSeverity["Error"] = "Error";
+})(CheckResultSeverity || (exports.CheckResultSeverity = CheckResultSeverity = {}));
+function isWarning(severity) {
+    return severity === CheckResultSeverity.Warning;
+}
+function isInfo(severity) {
+    return severity === CheckResultSeverity.Info;
+}

package/dist/courseFormat/CheckStatus.d.ts

@@ -0,0 +1,5 @@
+export declare enum CheckStatus {
+    Unchecked = "Unchecked",
+    Failed = "Failed",
+    Solved = "Solved"
+}

package/dist/courseFormat/CheckStatus.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckStatus = void 0;
+var CheckStatus;
+(function (CheckStatus) {
+    CheckStatus["Unchecked"] = "Unchecked";
+    CheckStatus["Failed"] = "Failed";
+    CheckStatus["Solved"] = "Solved";
+})(CheckStatus || (exports.CheckStatus = CheckStatus = {}));

package/dist/courseFormat/Course.d.ts

@@ -0,0 +1,68 @@
+import { LessonContainer } from "./LessonContainer";
+import { CourseMode } from "./CourseMode";
+import { CourseVisibility } from "./CourseVisibility";
+import { EduFile } from "./EduFile";
+import { PluginInfo } from "./PluginInfo";
+import { UserInfo } from "./UserInfo";
+import { Vendor } from "./Vendor";
+import { Lesson } from "./Lesson";
+import { Section } from "./Section";
+import { ItemContainer } from "./ItemContainer";
+export declare abstract class Course extends LessonContainer {
+    description: string;
+    environment: string;
+    environmentSettings: Record<string, string>;
+    courseMode: CourseMode;
+    solutionsHidden: boolean;
+    disabledFeatures: string[];
+    visibility: CourseVisibility;
+    additionalFiles: EduFile[];
+    pluginDependencies: PluginInfo[];
+    private nonEditableFiles;
+    authors: UserInfo[];
+    isLocal: boolean;
+    needWriteYamlText: boolean;
+    languageCode: string;
+    get type(): string;
+    get title(): string;
+    set title(value: string);
+    get language(): string;
+    get content(): Lesson[];
+    isMarketplace: boolean;
+    vendor?: Vendor;
+    marketplaceCourseVersion: number;
+    organization?: string;
+    isMarketplacePrivate: boolean;
+    createDate: Date;
+    feedbackLink?: string;
+    license?: string;
+    customContentPath: string;
+    private _languageId;
+    languageVersion?: string;
+    private _programmingLanguage;
+    get programmingLanguage(): string;
+    set programmingLanguage(value: string | null);
+    get languageId(): string;
+    set languageId(value: string);
+    initCourse(isRestarted: boolean): void;
+    init(parentItem: ItemContainer, isRestarted: boolean): void;
+    getLesson(sectionName?: string, lessonName?: string): Lesson | undefined;
+    getLesson(param?: string | number | ((lesson: Lesson) => boolean)): Lesson | undefined;
+    get sections(): Section[];
+    addSection(section: Section): void;
+    removeSection(section: Section): void;
+    getSection(name: string): Section | undefined;
+    getSection(predicate: (section: Section) => boolean): Section | undefined;
+    get course(): Course;
+    get itemType(): string;
+    get isStudy(): boolean;
+    sortItems(): void;
+    toString(): string;
+    get authorFullNames(): string[];
+    get humanLanguage(): string;
+    get isStepikRemote(): boolean;
+    incrementMarketplaceCourseVersion(remoteCourseVersion: number): void;
+    isEditableFile(path: string): boolean;
+    addNonEditableFile(path?: string | null): void;
+    removeNonEditableFile(path?: string | null): void;
+}