import * as i0 from '@angular/core';
import { HttpClient } from '@angular/common/http';
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
import { BaseApiResponse as BaseApiResponse$1, GenericBaseApiResponse as GenericBaseApiResponse$1 } from 'croco-generic-app-logic';

declare class TutorLogicModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TutorLogicModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TutorLogicModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TutorLogicModule>;
}

interface BaseApiResponse {
    isSucceeded: boolean;
    message: string;
}
interface GenericBaseApiResponse<T> extends BaseApiResponse {
    responseObject: T;
}
interface GetListResult<T> {
    totalCount: number;
    list: Array<T>;
}

interface CreateTestRequest {
    name: string;
    subjectId: string;
    sourceType: string;
    description: string;
    isActive: boolean;
    questionIds: Array<string>;
}
interface EditTestRequest {
    id: string;
    name: string;
    subjectId: string;
    description: string;
    isActive: boolean;
}
interface SearchTestsRequest {
    q: string;
    subjectIds: Array<string>;
    isActive: boolean | null;
    useSourceType: boolean;
    sourceType: string;
    schoolId: string;
    count: number | null;
    offSet: number;
}

interface SubjectModel {
    id: string;
    name: string;
    alias: string;
}
interface CreateSubjectRequest {
    name: string;
    alias: string;
    iconAlias: string;
    clarificationValues: Array<string>;
}
interface UpdateSubjectRequest {
    id: string;
    name: string;
    alias: string;
    iconAlias: string;
    clarificationValues: Array<string>;
}
interface SubjectCountsModel {
    id: string;
    alias: string;
    iconAlias: string;
    name: string;
    questionsCount: number;
    testsCount: number;
    clarificationValues: Array<string>;
}
interface OrderSubjectsRequest {
    ids: Array<string>;
}
interface SubjectWithClarificationsModel {
    id: string;
    name: string;
    alias: string;
    iconAlias: string;
    clarificationValues: Array<string>;
}
interface SubjectWithIconModel {
    id: string;
    name: string;
    alias: string;
    iconAlias: string;
    icon: IconSimpleModel$1;
}
interface IconSimpleModel$1 {
    id: string;
    setId: string;
    name: string;
    fileId: number;
}
interface SubjectMenuWithIconsModel {
    id: string;
    isMain: boolean;
    iconSetId: string;
    subjects: Array<SubjectWithIconModel>;
}
interface CreateSubjectMenuRequest {
    isMain: boolean;
    name: string;
    iconSetId: string;
}
interface SubjectMenuSimpleModel {
    id: string;
    name: string;
    isMain: boolean;
    iconSetId: string;
}

interface TutorFullApplicationPublicOptions {
    applicationName: string;
    applicationUrl: string;
    customMainHostUrl: string;
    multiSchoolOptions: MultiSchoolOptions;
    telegramBotSettings: MainTelegramBotSettings;
    studentDemo: StudentDemoSettings;
    mainMenu: SubjectMenuWithIconsModel;
    sizeTypeAndFileIdImageUrlFormat: string;
    fileIdAndNamePathUrlFormat: string;
    imagesPack: TutorImagesPackSettings;
    icon: IconApplicationSettings;
    webAppRoutes: WebAppRoutes;
    telephoneInputOptions: TelephoneInputOptions;
    userAgreements: UserAgreementsOptions;
    crocoHtmlLinkTagCustomFileIconOptions: CrocoHtmlLinkTagCustomIconOptions;
    serverAppVersion: string;
    dataOnUtc: string;
}
interface CrocoHtmlLinkTagCustomIconOptions {
    iconRenderUrlFormat: string;
    allowedTypes: Array<string>;
    defaultIcon: string;
    iconWidth: number;
    iconHeight: number;
}
interface UserAgreementsOptions {
    useRegistrationCheckBox: boolean;
    registrationCheckBoxHtml: string;
    userAgreementUrl: string;
    personalDataProcessingPolicyUrl: string;
}
interface MultiSchoolOptions {
    schoolRegistrationEnabled: boolean;
    infoEmail: string;
}
interface IconApplicationSettings {
    currentIconSetId: string;
}
interface StudentDemoSettings {
    demoRegistrationEnabled: boolean;
}
interface MainTelegramBotSettings {
    hasBot: boolean;
    botName: string;
    toBotWebButtonText: string;
}
interface TutorImagesPackSettings {
    error: string;
    success: string;
    solutionFinished: string;
    solutionCard: string;
}
interface IconApplicatonSettings {
    currentIconSetId: string;
}
interface WebAppRoutes {
    toGroupFormat: string;
    loginLinkFormat: string;
    schedules: string;
    materials: string;
    courseShop: string;
}
interface TelephoneInputOptions {
    useInput: boolean;
}

interface StudentSimpleModel {
    id: string;
    surname: string;
    name: string;
    patronymic: string;
    email: string;
    noEmail: boolean;
    phoneNumber: string;
    noPhoneNumber: boolean;
    telegramUserName: string;
    telegramUserId: number | null;
    avatarFileId: number | null;
    isDeleting: boolean;
}
interface SearchStudentsRequest {
    q: string;
    isDemo: boolean | null;
    schoolId: string;
    count: number | null;
    offSet: number;
}
interface RegisterStudentRequest {
    registrationRequest: RegisterModel;
    schoolId: string;
    invitationId: string;
    setRandomPassword: boolean;
}
interface StudentRegistrationResult {
    succeeded: boolean;
    message: string;
    studentId: string;
    alreadyExistingUserId: string;
    registeredUser: RegisteredUser;
}
interface RegisteredUser {
    id: string;
    noPhoneNumber: boolean;
    phoneNumber: string;
    noEmail: boolean;
    email: string;
}
interface RegisterModel {
    email: string;
    noEmail: boolean;
    name: string;
    surname: string;
    patronymic: string;
    phoneNumber: string;
    noPhoneNumber: boolean;
    password: string;
}

interface IconSimpleModel {
    id: string;
    setId: string;
    name: string;
    fileId: number | null;
}

interface SearchStudentGroupsRequest {
    q: string;
    schoolId: string;
    types: Array<StudentGroupType>;
    count: number | null;
    offSet: number;
}
declare enum StudentGroupType {
    Course = "Course",
    ClassRoom = "ClassRoom",
    ExternalProduct = "ExternalProduct"
}
declare enum StudentGroupTaskType {
    LinkCourseTemplate = "LinkCourseTemplate",
    ClearSolutions = "ClearSolutions"
}
interface StudentGroupSimpleModel {
    id: string;
    alias: string;
    name: string;
    isDeleting: boolean;
    useHtmlForName: boolean;
    useCourse: boolean;
    type: StudentGroupType;
    nameHtml: string;
    isFreeOfCharge: boolean;
    schoolId: string;
    courseShopWindowId: string;
    hasNotProcessedTask: boolean;
}
interface StudentGroupDetailedModel {
    id: string;
    name: string;
    alias: string;
    enterCode: string;
    useCourse: boolean;
    studentsCount: number;
    isDeleting: boolean;
    type: StudentGroupType;
    courseTemplateId: string;
    useHtmlForName: boolean;
    nameHtml: string;
    useSchedule: boolean;
    scheduleId: string;
    useMaterials: boolean;
    materialsHtml: string;
    solutionsCount: number;
    scheduleStudentSubscribersCount: number;
    hasDefaultLandingPage: boolean;
    defaultCourseLandingPageUrl: string;
    schoolId: string;
    courseShopWindowId: string;
    computedDataOnUtc: string;
    task: StudentGroupTaskType | null;
    taskInfo: StudentGroupTaskInfo;
}
interface StudentGroupTaskInfo {
    title: string;
    description: string;
}
interface StudentInGroupSimpleModel {
    student: StudentSimpleModel;
    isBlocked: boolean;
    shouldBlockOnUtc: string;
    enteredOnUtc: string;
}
interface SearchStudentsInGroup {
    groupId: string;
    q: string;
    hasIndividualPaymentPlans: boolean | null;
    isBlocked: boolean | null;
    count: number | null;
    offSet: number;
}
interface StudentTestGroupRelationDetailedModel {
    studentGroupId: string;
    testId: string;
    canCheckSingleQuestion: boolean;
    html: string;
    showHtml: boolean;
    testName: string;
    testDescription: string;
}
interface SearchStudentGroupsByStudentRequest {
    studentId: string;
    q: string;
    iconSetId: string | null;
    count: number | null;
    offSet: number;
}
interface StudentGroupWithCourseProgressModel {
    groupId: string;
    groupName: string;
    groupUseHtmlForName: boolean;
    groupNameHtml: string;
    useCourse: boolean;
    isBlocked: boolean;
    shouldBlockOnUtc: string | null;
    courseProgress: StudentGroupCourseProgressSimpleModel;
    icon: IconSimpleModel;
}
interface StudentGroupCourseProgressSimpleModel {
    totalWeight: number;
    currentProgress: number;
    progressPercents: number;
}

interface GetToGroupByCodeRequest {
    enterCode: string;
}
interface EnterGroupResponse {
    succeeded: boolean;
    errorMessage: string;
    groupId: string;
    groupName: string;
    groupType: StudentGroupType;
}

declare enum TestQuestionType {
    SelectRightAnswerOrAnswers = "SelectRightAnswerOrAnswers",
    TypeRightAnswer = "TypeRightAnswer",
    DetailedAnswer = "DetailedAnswer",
    TypeAnswerWithErrors = "TypeAnswerWithErrors",
    ManyAnswersBoxes = "ManyAnswersBoxes",
    FillGaps = "FillGaps"
}
declare enum GapType {
    Select = "Select",
    Input = "Input"
}
interface GapModel {
    type: GapType;
    correctAnswers: Array<string>;
    answersToSelect: Array<string>;
}
interface GapsQuestionData {
    gapText: string;
    gaps: Array<GapModel>;
}
interface TestQuestionModel {
    id: string;
    title: string;
    titleBodyMarkUp: string;
    helpBodyMarkUp: string;
    answerExplanationMarkUp: string;
    versionId: string;
    type: TestQuestionType;
    selectRightAnswerOrAnswersData: SelectRightAnswerOrAnswersQuestionData;
    typeRightAnswerQuestionData: TypeRightAnswerQuestionData;
    typeAnswerWithErrorsData: TypeAnswerWithErrorsQuestionData;
    manyAnswersBoxesData: ManyAnswersBoxesQuestionData;
    gapsData: GapsQuestionData;
}
interface ManyAnswersBoxesQuestionData {
    answerBoxes: Array<QuestionAnswerBox>;
}
interface QuestionAnswerBox {
    label: string;
    correctAnswer: string;
}
interface TypeAnswerWithErrorsQuestionData {
    rightAnswer: string;
    ignoreTextOrder: boolean;
}
interface SelectRightAnswerOrAnswersQuestionData {
    selectRightAnswerTitle: string;
    useRadio: boolean;
    itemType: SelectRightAnswerOrAnswersQuestionDataItemType | null;
    answers: Array<Answer>;
}
interface Answer {
    text: string;
    data: string;
    isRightAnswer: boolean;
}
declare enum SelectRightAnswerOrAnswersQuestionDataItemType {
    FileId = "FileId",
    MarkUp = "MarkUp"
}
interface TypeRightAnswerQuestionData {
    caseInSensitive: boolean;
    rightAnswers: Array<string>;
}

interface TestSolutionWithPointsValidation {
    solutionId: string;
    isFinished: boolean;
    hasPointsResult: boolean;
    questions: QuestionAnswerWithResult[];
    studentTotalPoints: number;
    maxTotalPoints: number;
    questionsCount: number;
    validatedQuestionsCount: number;
    inProcessQuestionsCount: number;
    hasRightAnswerQuestionsCount: number;
}
declare enum QuestionValidationSourceType {
    System = "System",
    Student = "Student",
    Curator = "Curator"
}
interface TestQuestionWithModifiers {
    questionId: string;
    modifiers: TestQuestionModiferModel[];
}
interface TestQuestionModiferModel {
    name: string;
    data: string;
}
interface SaveQuestionPointsValidation {
    idModel: QuestionInSolutionIdModel;
    answerPoints: number;
    questionTotalPoints: number;
    description: string;
}
interface QuestionInSolutionIdModel {
    solutionId: string;
    questionId: string;
}

interface StudentTestQuestionStatisticDetailedModel {
    id: string;
    studentId: string;
    questionVersionId: string;
    errorsAnswersCount: number;
    almostRightAnswersCount: number;
    rightAnswersCount: number;
    score: number;
    question: TestQuestionModel;
}
interface SearchTestQuestionErrorsStatisticRequest {
    isLastAnswerCorrect: boolean | null;
    isActualQuestionVersion: boolean | null;
    studentId: string;
    questionTypes: Array<TestQuestionType>;
    orderType: TestQuestionErrorsStatisticOrderType;
    count: number | null;
    offSet: number;
}
declare enum TestQuestionErrorsStatisticOrderType {
    MostErrors = "MostErrors",
    RecentErrors = "RecentErrors"
}
interface QuestionStatisticComputingState {
    toComputeQuestionReportsCount: number;
    notActualQuestionVersionReportsCount: number;
    toComputeStudentSnapshotsCount: number;
    toComputeStudentGroupSnapshotsCount: number;
    toComputeAggregatedSnapshotRequestsCount: number;
    toRecomputeIsActualVersionPropertyCount: number;
    dataOnUtc: string;
}
interface StudentStatisticSnapshotValueModel {
    studentId: string;
    dataOnUtc: string;
    computedOnUtc: string;
    recomputingRequired: boolean;
    checkedQuestionsCount: number;
    tags: Array<StudentStatisticSnapshotTagValueModel>;
    subjects: Array<StudentStatisticSnapshotSubjectValueModel>;
}
interface StudentStatisticSnapshotValueDebugInfoModel {
    hasSnapshot: boolean;
    studentId: string;
    dataOnUtc: string;
    computedOnUtc: string;
    recomputingRequired: boolean;
    lastRecomputingRequiredSetOnUtc: string;
    checkedQuestionsCount: number;
    lastQuestionAnsweredOnUtc: string;
    lastQuestionAggregateComputedOnUtc: string;
}
interface StudentStatisticSnapshotTagValueModel {
    tagId: string;
    tagDisplayName: string;
    statistic: ComputedStatisticPresentationModel;
}
interface ComputedStatisticPresentationModel {
    errorsAnswersCount: number;
    almostRightAnswersCount: number;
    rightAnswersCount: number;
    score: number;
    attemptsWithScoreTotalCount: number;
    totalAttemptsCount: number;
    successRatePercents: string;
    successRateRankValue: number;
    earnedPoints: number;
    totalPoints: number;
}
interface StudentStatisticSnapshotSubjectValueModel {
    subjectId: string;
    subjectName: string;
    statistic: ComputedStatisticPresentationModel;
}

interface SearchStudentTestSolutionsRequest {
    isFinished: boolean | null;
    studentId: string;
    testId: string;
    withUnreadMessages: boolean;
    count: number | null;
    offSet: number;
}
interface TestSolutionCourseData {
    solutionId: string;
    courseThemeItemId: string;
    courseThemeItemIndex: number;
    courseThemeId: string;
    courseThemeName: string;
    courseName: string;
    courseId: string;
    testId: string;
}
interface SolutionWithAnswerModel {
    solutionId: string;
    answer: QuestionAnswer;
}
interface QuestionAnswer {
    questionId: string;
    answerOrAnswers: string;
}
interface StudentTestSolutionWithChatInfo {
    solution: StudentTestSolutionSimpleModel;
    systemValidation: TestSolutionSystemValidationModel;
    unreadMessagesCount: number;
}
interface StudentTestSolutionWithStudentAndChatInfo {
    solution: StudentTestSolutionSimpleModel;
    student: StudentSimpleModel;
    systemValidation: TestSolutionSystemValidationModel;
    unreadMessagesCount: number;
}
interface TestSolutionSystemValidationModel {
    studentTotalPoints: number;
    studentProgressPercents: number;
    maxTotalPoints: number;
    questionsCount: number;
    validatedQuestionsCount: number;
    hasRightAnswerQuestionsCount: number;
}
interface StartSolutionFromDirectoryRequest {
    workSpaceId: string;
    directoryId: string;
    useFilter: boolean;
    canCheckSingleQuestion: boolean;
    filter: QuestionsFilter;
}
interface CreateTestForStudentErrorsRequest {
    testName: string;
    questionsCount: number;
    questionTypes: Array<TestQuestionType>;
    orderType: TestQuestionErrorsStatisticOrderType;
    canCheckSingleQuestion: boolean;
    isLastAnswerCorrect: boolean | null;
    isActualQuestionVersion: boolean | null;
}
interface TestSolutionCreatedResult {
    succeeded: boolean;
    errorMessage: string;
    solutionId: string;
}
interface QuestionsFilter {
    types: Array<TestQuestionType>;
}
interface StartTestSolutionByTestIdRequest {
    testId: string;
    studentGroupId: string;
    canCheckSingleQuestion: boolean;
}
interface SearchMyTestSolutionsRequest {
    isFinished: boolean | null;
    testId: string;
    withUnreadMessages: boolean;
    count: number | null;
    offSet: number;
}
interface StudentTestSolutionSimpleModel {
    id: string;
    testName: string;
    testId: string;
    isFinished: boolean;
    startedOnUtc: string;
    finishedOnUtc: string | null;
}
declare enum AnswerValidationResultType {
    NeedToCheckByYourSelf = "NeedToCheckByYourSelf",
    NotCorrectAnswer = "NotCorrectAnswer",
    PartiallyCorrectAnswer = "PartiallyCorrectAnswer",
    CorrectAnswer = "CorrectAnswer",
    InProcess = "InProcess"
}
interface SolutionWithAnswersModel {
    solutionId: string;
    answers: Array<QuestionAnswer>;
}
interface StudentTestSolutionModel {
    solutionId: string;
    hasCuratorValidation: boolean;
    canCheckSingleQuestion: boolean;
    studentId: string;
    startedOnUtc: string;
    studentGroupId: string;
    finishedOnUtc: string | null;
    isFinished: boolean;
    solution: StudentTestSolutionDataModel;
    test: TestModel;
}
interface StudentTestSolutionDataModel {
    /**
     * Есть ли вопросы, которые находятся в процессе расчёта результата
    */
    hasAnswersInProcess: boolean;
    answers: Array<QuestionAnswerWithResult>;
}
interface TestModel {
    name: string;
    description: string;
    questions: Array<TestQuestionModel>;
}
interface TestWithActiveSolutionModel {
    testId: string;
    activeSolutionId: string;
    test: TestModel;
}
interface QuestionAnswerWithResult {
    isChecked: boolean;
    questionId: string;
    answerOrAnswers: string;
    pointsValidation: QuestionPointsValidationModel;
    resultType: AnswerValidationResultType;
}
interface QuestionPointsValidationModel {
    errorOccured: boolean;
    inProcess: boolean;
    answerPoints: number;
    questionTotalPoints: number;
    description: string;
    isValidated: boolean;
    sourceType: QuestionValidationSourceType;
    validatorId: string;
}
interface StudentTestSolutionDetailedModel {
    solutionId: string;
    hasAnswersInProcess: boolean;
    hasCuratorValidation: boolean;
    canCheckSingleQuestion: boolean;
    studentId: string;
    startedOnUtc: string;
    finishedOnUtc: string | null;
    isFinished: boolean;
    studentGroupId: string;
    marketingOptions: SolutionMarketingOptions;
    test: StudentTestSolutionDetailedTestModel;
}
interface SolutionMarketingOptions {
    showAfterSolutionMarkUp: boolean;
    afterSolutionMarkUp: string;
}
interface StudentTestSolutionDetailedTestModel {
    name: string;
    description: string;
    questions: Array<StudentTestSolutionDetailedTestQuestion>;
}
interface StudentTestSolutionDetailedTestQuestion {
    question: TestQuestionModel;
    answerWithValidation: QuestionAnswerWithResult;
    isQuestionLikedByStudent: boolean;
}

interface SearchQuestionsByLikes {
    studentId: string;
    count: number | null;
    offSet: number;
}

interface CourseDetailedModel {
    id: string;
    name: string;
    schoolId: string;
    templateId: string;
    weight: number;
    versionId: string;
    themes: Array<CourseThemeDetailedModel>;
}
interface CourseSimpleModel {
    id: string;
    name: string;
    weight: number;
    versionId: string;
    templateVersionId: string;
    needsUpdating: boolean;
}
interface CourseThemeDetailedModel {
    id: string;
    name: string;
    description: string;
    weight: number;
    courseVersionId: string;
    items: Array<CourseThemeItemModel>;
}
interface CourseThemeItemModel {
    id: string;
    name: string;
    html: string;
    weight: number;
    templateItemId: string;
    userInterfaceSettings: CourseThemeItemUISettingsModel;
    computedThemeProgress: ProgressModel;
    tests: Array<CourseThemeItemTestModel>;
}
interface ProgressModel {
    weight: number;
    progressPercents: number;
}
interface CourseThemeItemUISettingsModel {
    previousSlideBtnText: string;
    nextSlideBtnText: string;
}
interface CourseThemeItemTestModel {
    testId: string;
    testName: string;
    totalPointsToPass: number;
    totalPercentageToPass: number;
    canCheckSingleQuestion: boolean;
}

interface CreateOrUpdateCuratorMessageTemplate {
    questionId: string;
    name: string;
    text: string;
}
interface CuratorMessageTemplateModel {
    name: string;
    text: string;
}
interface SearchCuratorMessageTemplates {
    questionId: string;
    name: string;
    count: number | null;
    offSet: number;
}
interface DeleteCuratorMessageTemplate {
    questionId: string;
    name: string;
}

interface CourseItemGlobalTestRestrictionModel {
    courseThemeItemId: string;
    testId: string;
    testRestriction: TestRestrictionModel;
}
interface TestRestrictionModel {
    maxTriesCount: number | null;
    maxStartDate: string | null;
}
interface SearchStudentThemeItemTestRestrictionsRequest {
    q: string;
    courseThemeItemId: string;
    testId: string;
    isIndividual: boolean | null;
    count: number | null;
    offSet: number;
}
interface ThemeItemTestStudentRestrictionModel {
    restriction: TestRestrictionModel;
    isIndividual: boolean;
    testId: string;
    testName: string;
    student: StudentSimpleModel;
}
interface CourseItemStudentTestRestrictionModel {
    courseThemeItemId: string;
    studentId: string;
    testId: string;
    isIndividual: boolean;
    testRestriction: TestRestrictionModel;
}
interface TestRestrictionValidationResult {
    testRestriction: TestRestrictionModel;
    canStartTest: boolean;
    restrictionRuleType: TestRestrictionValidationResultRuleType | null;
    validationMessage: string;
    solutionsCount: number;
    attemptsLeft: number;
}
declare enum TestRestrictionValidationResultRuleType {
    DateExpired = "DateExpired",
    AttemptsExceeded = "AttemptsExceeded"
}
interface GetCourseThemeItemStudentTestRestrictionRequest {
    courseThemeItemId: string;
    testId: string;
    studentId: string;
}
interface TestRestrictionValidationWithDeadLineWarningResult {
    deadLineWarning: DeadLineWithWarningMessage;
    restrictionValidationResult: TestRestrictionValidationResult;
}
interface CourseThemeItemStudentDeadlineWarningModel {
    themeItemId: string;
    courseThemeId: string;
    deadLine: string;
    warningMessage: string;
}
interface GetStudentCourseThemeItemsDeadlineWarningsRequest {
    courseId: string;
    studentId: string;
}
interface CourseThemeIdWithDeadlineWarnings {
    courseThemeId: string;
    deadlines: Array<DeadLineWithWarningMessage>;
}
interface DeadLineWithWarningMessage {
    deadLine: string;
    warningMessage: string;
}
interface CourseRemovingAllTestRestrictionsState {
    taskId: string;
    inProcess: boolean;
    state: CourseRemovingAllTestRestrictionsStateModel;
}
interface CourseRemovingAllTestRestrictionsStateModel {
    courseId: string;
    themeIdsLeftToUpdate: Array<string>;
    totalThemesToUpdateCount: number;
    updateProgressPercents: number;
}

interface StudentCourseItemTestSolution {
    solutionId: string;
    startedOnUtc: string;
    isFinished: boolean;
    validation: StudentCourseItemTestSolutionValidationModel;
    totalPointsToPass: number;
}
interface StudentCourseItemTestSolutionValidationModel {
    studentTotalPoints: number;
    maxTotalPoints: number;
    pointsPercentage: number;
}
interface CourseThemeItemsTestSolutionsRestrictionsModel {
    testId: string;
    testName: string;
    finished: boolean;
    solutions: StudentCourseItemTestSolution[];
    restrictionResult: TestRestrictionValidationWithDeadLineWarningResult;
}

interface CmsPageBlockModel {
    id: string;
    versionId: string;
    name: string;
    description: string;
    dataJson: string;
    dataType: string;
    isVisible: boolean;
}
interface CmsPageModel {
    title: string;
    navigationItems: Array<CmsPageNavigationItem>;
    properties: CmsPropertiesModel;
    buttons: Array<CmsPageButton>;
}
interface CmsPageButton {
    id: string;
    button: CmsButton;
}
interface CmsPageNavigationItem {
    id: string;
    name: string;
}
interface CmsPropertiesModel {
    booleans: Array<CmsBooleanProperty>;
    strings: Array<CmsStringProperty>;
}
interface CmsBooleanProperty {
    name: string;
    value: boolean;
}
interface CmsStringProperty {
    name: string;
    value: string;
}
interface CmsButton {
    text: string;
    type: string;
    clickHandler: string;
}

interface CreateCourseOrderRequest {
    courseId: string;
    tariffId: string;
    isFreeOfCharge: boolean;
    source: string;
    sourceDescription: string;
}
interface CreateCourseOrderResponse {
    succeeded: boolean;
    id: string;
    errorMessage: string;
}
interface CourseOrderModel {
    id: string;
    courseId: string;
    tariffId: string;
    isFreeOfCharge: boolean;
    userId: string;
    isFinished: boolean;
    courseWithPlans: StudentGroupWithPaymentPlansModel;
}
interface CourseShopWindowDetailedModel {
    id: string;
    name: string;
    description: string;
    courses: Array<CourseShopWindowItemDetailedModel>;
    dataOnUtc: string;
}
interface CourseShopWindowItemDetailedModel {
    id: string;
    name: string;
    getCourseMiniHtml: string;
    getCourseDetailedHtml: string;
    studentGroup: StudentGroupSimpleModel;
    cardOptions: CourseShopWindowItemCardOptionsModel;
    globalPaymentPlans: Array<StudentGroupPaymentPlanSimpleModel>;
}
interface CourseShopWindowItemModel {
    id: string;
    name: string;
    studentGroup: StudentGroupSimpleModel;
    cardOptions: CourseShopWindowItemCardOptionsModel;
}
interface CourseShopWindowItemCardOptionsModel {
    color: string;
    imageSrc: string;
}
interface StudentGroupWithPaymentPlansModel {
    studentGroupName: string;
    studentGroupId: string;
    studentGroupAlias: string;
    getCourseMiniHtml: string;
    getCourseDetailedHtml: string;
    isFreeOfCharge: boolean;
    paymentPlans: Array<StudentGroupPaymentPlanSimpleModel>;
}
interface StudentGroupPaymentPlanSimpleModel {
    id: string;
    name: string;
    description: string;
    daysLength: number;
    amount: number;
    paymentsCountForUnlimitedAccess: number | null;
}
interface StudentGroupPaymentPlansModel {
    id: string;
    alias: string;
    isFreeOfCharge: boolean;
    globalPaymentPlans: Array<StudentGroupGlobalPaymentPlanModel>;
}
interface StudentGroupGlobalPaymentPlanModel {
    id: string;
    name: string;
    description: string;
    daysLength: number;
    amount: number;
    defaultLandingPageUrl: string;
}

interface CourseLandingPageSimpleModel {
    id: string;
    name: string;
    description: string;
    groupId: string;
    groupName: string;
}
interface SearchCourseLandingPageRequest {
    studentGroupId: string;
    count: number | null;
    offSet: number;
}
interface CourseLandingPageDetailedModel {
    id: string;
    name: string;
    studentGroupId: string;
    isFreeOfCharge: boolean;
    description: string;
    paymentPlans: Array<StudentGroupPaymentPlanSimpleModel>;
    blocks: Array<CmsPageBlockModel>;
    page: CmsPageModel;
}

/**
 * Модель для добавления запроса в избранное
 */
interface ChangeQuestionLike {
    /**
     * Идентификатор вопроса
     */
    questionId: string;
    /**
     * Добавлен ли данный вопрос в избранное
     */
    hasLike: boolean;
}
interface QuestionIdWithLike {
    questionId: string;
    hasLike: boolean;
}

interface StartCourseThemeRequest {
    themeProgressId: string;
}
interface UpdateStudentCourseThemeProgressRequest {
    studentProgressId: string;
    themeId: string;
    currentItemIndex: number | null;
    finishThemeItemId: string | null;
}
interface StartCourseThemeItemTestRequest {
    studentProgressId: string;
    itemId: string;
    testId: string;
}
interface StartCourseThemeItemTestResult {
    succeeded: boolean;
    solutionId: string;
    errorMessage: string;
}
interface UpdateStudentCourseThemeProgressResult {
    succeeded: boolean;
    errorMessage: string;
    themeProgress: number;
    themeFinished: boolean;
    finishedThemeItemResponse: BaseApiResponse | null;
}
interface StudentCourseProgressModel {
    id: string;
    studentId: string;
    courseId: string;
    currentProgress: number;
    courseTotalWeight: number;
    currentThemeIndex: number;
    currentProgressPercents: number;
    themes: StudentCourseThemeProgressModel[];
    lastThemeId: string | null;
}
interface StudentCourseThemeProgressModel {
    id: string;
    themeId: string;
    isStarted: boolean;
    isRestricted: boolean;
    currentProgress: number;
    currentItemIndex: number;
    themeTotalWeight: number;
    currentProgressPercents: number;
    isFinished: boolean;
    finishedOnUtc: string;
    updatedOnUtc: string;
    items: StudentCourseThemeProgressItemModel[];
}
interface StudentCourseThemeProgressItemModel {
    id: string;
    isFinished: boolean;
}
interface SearchCourseProgressesRequest {
    courseId: string;
    count: number | null;
    offSet: number;
}
interface StudentCourseProgressWithStudentModel {
    id: string;
    student: StudentSimpleModel;
    courseId: string;
    currentProgress: number;
    courseTotalWeight: number;
    currentThemeIndex: number;
    currentProgressPercents: number;
}

interface SearchStudentGroupMaterialsRequest {
    studentId: string;
    count: number | null;
    offSet: number;
}
interface StudentGroupWithMaterialsModel {
    groupId: string;
    groupName: string;
    materialsHtml: string;
    isBlockedInGroup: boolean;
}

interface AddCoursePaymentRequest {
    planId: string;
    isPrivatePaymentPlan: boolean;
    type: StudentCoursePaymentType;
    courseId: string;
    source: string;
    sourceDescription: string;
    paymentSystemId: string;
}
declare enum StudentCoursePaymentType {
    BuyCourse = "BuyCourse",
    ExtendSubscription = "ExtendSubscription"
}
interface AddCoursePaymentResult {
    succeeded: boolean;
    coursePaymentId: string;
    errorMessage: string;
}
interface SetPaymentSystemForCoursePayment {
    coursePaymentId: string;
    paymentSystemId: string;
}
interface DemoPaymentDescription {
    html: string;
}
interface StudentCoursePaymentModel {
    id: string;
    name: string;
    description: string;
    courseName: string;
    courseMiniHtml: string;
    courseDetailedHtml: string;
    daysLength: number;
    amount: number;
    amountString: string;
    paymentId: string;
    studentGroupId: string;
    paymentSystemId: string;
    paymentSystemProviderName: string;
    isFinished: boolean;
    isPaid: boolean;
    type: StudentCoursePaymentType;
    studentProcessedToGroup: boolean;
    hasError: boolean;
    errorType: string;
    errorMessage: string;
    providerErrorType: string;
    providerErrorMessage: string;
    createdOnUtc: string;
    paidOnUtc: string;
    finishedOnUtc: string;
}
interface SearchStudentCoursePaymentsRequest {
    q: string;
    studentId: string;
    groupId: string;
    isPaid: boolean | null;
    paymentType: StudentCoursePaymentType | null;
    hasError: boolean | null;
    count: number | null;
    offSet: number;
}
interface StudentCoursePaymentDetailedModel {
    id: string;
    name: string;
    description: string;
    courseName: string;
    courseMiniHtml: string;
    courseDetailedHtml: string;
    daysLength: number;
    amount: number;
    amountString: string;
    paymentId: string;
    paymentSystemId: string;
    paymentSystemProviderName: string;
    isFinished: boolean;
    isPaid: boolean;
    studentProcessedToGroup: boolean;
    hasError: boolean;
    errorType: string;
    errorMessage: string;
    providerErrorType: string;
    providerErrorMessage: string;
    createdOnUtc: string;
    paidOnUtc: string;
    finishedOnUtc: string;
    type: StudentCoursePaymentType;
    student: StudentSimpleModel;
    group: StudentGroupSimpleModel;
}
interface EnumValueTypeWithDescriptionStudentCoursePaymentType {
    type: StudentCoursePaymentType;
    description: string;
}

interface GetStudentGroupCourseAccessRequest {
    groupId: string;
    timeZoneMinutesOffSet: number | null;
}
interface StudentGroupCourseWithDetailedAccessModel {
    id: string;
    hasAccess: boolean;
    name: string;
    alias: string;
    useCourse: boolean;
    useHtmlForName: boolean;
    nameHtml: string;
    useMaterials: boolean;
    materialsHtml: string;
    course: CourseDetailedModel;
    isBlocked: boolean;
    shouldBlockOnUtc: string | null;
    notification: StudentGroupAccessProlongationNotification;
    showProlongationPaymentPlans: boolean;
    isFreeOfCharge: boolean;
    globalPaymentPlans: Array<StudentGroupPaymentPlanSimpleModel>;
    privatePaymentPlans: Array<StudentGroupPaymentPlanSimpleModel>;
}
interface StudentGroupAccessProlongationNotification {
    title: string;
    text: string;
}

interface PaymentSystemModel {
    id: string;
    name: string;
    providerName: string;
    groupId: string;
    displayName: string;
    description: string;
    enabled: boolean;
}
interface SearchPaymentSystemsRequest {
    enabled: boolean | null;
    count: number | null;
    offSet: number;
}
interface OrderPaymentSystemsRequest {
    systemIds: Array<string>;
}

interface DefaultCourseLandingPageModel {
    id: string;
    enabled: boolean;
    titleHtml: string;
    descriptionHtml: string;
    themeColor: string;
    backgroundImageSrc: string;
}

interface StudentGroupInfoPageDetailedModel {
    isUserAuthorized: boolean;
    isStudent: boolean;
    displayOptions: DefaultCourseLandingDisplayOptions;
    groupInfo: StudentGroupSimpleModel;
    landingPage: DefaultCourseLandingPageModel;
    studentAccess: StudentGroupInfoPageDetailedStudentAccessModel;
    globalPaymentPlans: Array<StudentGroupPaymentPlanSimpleModel>;
    privatePaymentPlans: Array<StudentGroupPaymentPlanSimpleModel>;
    paymentSystems: Array<PaymentSystemModel>;
}
interface DefaultCourseLandingDisplayOptions {
    notFoundPageTransparentLogoSrc: string;
    defaultBackgroundImageSrc: string;
}
interface StudentGroupInfoPageDetailedStudentAccessModel {
    isBlocked: boolean;
    showProlongationPaymentPlans: boolean;
    notification: StudentGroupAccessProlongationNotification;
}
interface GetStudentGroupInfoPageRequest {
    groupAliasOrId: string;
    timeZoneMinutesOffSet: number | null;
}

interface GetStudentInGroupStatisticSnapshotRequest {
    groupId: string;
    studentId: string;
    snapshotId: string;
}
interface StudentInGroupStatisticSnapshotModel {
    snapshotId: string;
    studentGroupName: string;
    actualFromUtc: string;
    createdOnUtc: string;
    subjectValues: Array<StudentInGroupStatisticBySubjectSnapshotValueModel>;
    tagValues: Array<StudentInGroupStatisticByTagSnapshotValueModel>;
}
interface StudentInGroupStatisticBySubjectSnapshotValueModel {
    id: string;
    subjectName: string;
    subjectId: string;
    place: number;
    studentsWithSameResultCount: number;
    statistic: ComputedStatisticPresentationModel;
}
interface StudentInGroupStatisticByTagSnapshotValueModel {
    id: string;
    tagId: string;
    tagDisplayName: string;
    place: number;
    studentsWithSameResultCount: number;
    statistic: ComputedStatisticPresentationModel;
}
interface StudentGroupStatisticSnapshotInfoModel {
    snapshotId: string;
    isComputed: boolean;
    studentGroupId: string;
    studentGroupName: string;
    uniqueStudentsWithTagCount: number;
    uniqueStudentsWithSubjectCount: number;
    studentsInGroupCount: number;
    studentsInGroupWithCheckedQuestionsCount: number;
    studentIdsWithoutStatistic: Array<string>;
}

interface TutorUserTelegramData {
    userId: string;
    telegramUserId: number | null;
    telegramUserName: string;
}
interface TelegramLinkResponse {
    command: string;
}

interface StudentInGroupSetBlockingDateModel {
    studentId: string;
    groupId: string;
    shouldBlockOnUtc: string;
}
interface StudentInGroupSetBlockingModel {
    studentId: string;
    groupId: string;
    isBlocked: boolean;
}
interface GetMyStudentGroupBlockRequest {
    groupId: string;
    timeZoneMinutesOffSet: number | null;
}
interface StudentInGroupWithBlockModel {
    studentId: string;
    groupId: string;
    isBlocked: boolean;
    shouldCreateCourseEntities: boolean;
    enteredOnUtc: string;
    shouldBlockOnUtc: string | null;
    showProlongationPaymentPlans: boolean;
    prolongationNotificationTitle: string;
    prolongationNotificationText: string;
}

declare class TestService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    searchGroupRelationsInTest(model: SearchTestsRequest): Observable<GetListResult<StudentGroupSimpleModel>>;
    create(model: CreateTestRequest): Observable<BaseApiResponse>;
    edit(model: EditTestRequest): Observable<BaseApiResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TestService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TestService>;
}

/**
* Методы контроллера StudentGroupQueryController
*/
declare class StudentGroupQueryService {
    private readonly _httpClient;
    private _baseUrl;
    getBaseUrl(): string;
    constructor(_httpClient: HttpClient, _baseUrl: string);
    /**
     * Поиск групп учеников
     */
    search(model: SearchStudentGroupsRequest): Observable<GetListResult<StudentGroupSimpleModel>>;
    searchWithProgresses(model: SearchStudentGroupsByStudentRequest): Observable<GetListResult<StudentGroupWithCourseProgressModel>>;
    /**
     * Получить группу по идентификатору
     * @param id идентификатор группы учеников
     * @returns группу учеников
     */
    getById(id: string): Observable<StudentGroupDetailedModel>;
    getByStudentId(id: string): Observable<StudentGroupSimpleModel[]>;
    /**
     * Получить список студентов в группе по фильтру
     * @param model модель для поиска
     * @returns список студентов
     */
    getStudentsList(model: SearchStudentsInGroup): Observable<GetListResult<StudentInGroupSimpleModel>>;
    /**
     * Получить студента в группе
     * @param groupId идентификатор группы
     * @param studentId идентификатор студента
     * @returns
     */
    getStudentById(groupId: string, studentId: string): Observable<StudentInGroupSimpleModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentGroupQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentGroupQueryService>;
}

declare class StudentQueryService {
    private _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    getById(id: string): Observable<StudentSimpleModel>;
    getByTelegramId(telegramId: number): Observable<StudentSimpleModel>;
    search(searchModel: SearchStudentsRequest): Observable<GetListResult<StudentSimpleModel>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentQueryService>;
}

declare class StudentGroupEnterService {
    private _httpClient;
    private readonly _baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    enterViaCode(model: GetToGroupByCodeRequest): rxjs.Observable<EnterGroupResponse>;
    enterFreeOfCharge(id: string): rxjs.Observable<EnterGroupResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentGroupEnterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentGroupEnterService>;
}

declare class TestSolutionQueryService {
    private readonly _httpClient;
    private readonly _baseUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    search(model: SearchStudentTestSolutionsRequest): rxjs.Observable<GetListResult<StudentTestSolutionWithChatInfo>>;
    searchDetailed(model: SearchStudentTestSolutionsRequest): rxjs.Observable<GetListResult<StudentTestSolutionWithStudentAndChatInfo>>;
    getCourseData(id: string): rxjs.Observable<TestSolutionCourseData>;
    getSolutionById(id: string): rxjs.Observable<StudentTestSolutionModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TestSolutionQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TestSolutionQueryService>;
}

/**
Методы контроллера Tutor.Api.Controllers.TestSolutions.TestSolutionResultController
BasePath = api/tutor/test-solution-result
*/
declare class TestSolutionResultService {
    private readonly _httpClient;
    readonly baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    getQuestionsWithModifiersBySolution(solutionId: string): rxjs.Observable<TestQuestionWithModifiers[]>;
    getQuestionsWithPointsValidationBySolution(solutionId: string): rxjs.Observable<TestSolutionWithPointsValidation>;
    create(solutionId: string): rxjs.Observable<BaseApiResponse>;
    recalculate(solutionId: string): rxjs.Observable<BaseApiResponse>;
    saveQuestionResult(model: SaveQuestionPointsValidation): rxjs.Observable<GenericBaseApiResponse<QuestionAnswerWithResult>>;
    removeQuestionResult(model: QuestionInSolutionIdModel): rxjs.Observable<GenericBaseApiResponse<QuestionAnswerWithResult>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TestSolutionResultService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TestSolutionResultService>;
}

declare class StudentTestSolutionStartService {
    private readonly _httpClient;
    private readonly baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    startByTestId(model: StartTestSolutionByTestIdRequest): Observable<TestSolutionCreatedResult>;
    startByDirectory(model: StartSolutionFromDirectoryRequest): Observable<TestSolutionCreatedResult>;
    startByErrors(model: CreateTestForStudentErrorsRequest): Observable<TestSolutionCreatedResult>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentTestSolutionStartService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentTestSolutionStartService>;
}

declare class OpenApiQuestionLikeService {
    private readonly _httpClient;
    private readonly _baseUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    search(model: SearchQuestionsByLikes): rxjs.Observable<GetListResult<TestQuestionModel>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenApiQuestionLikeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OpenApiQuestionLikeService>;
}

declare class OpenApiTestSolutionService {
    private readonly _httpClient;
    private readonly _baseUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    getById(id: string): rxjs.Observable<StudentTestSolutionModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenApiTestSolutionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OpenApiTestSolutionService>;
}

declare class StudentTestSolutionService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    checkAnswer(model: SolutionWithAnswerModel): Observable<GenericBaseApiResponse<QuestionAnswerWithResult>>;
    finishSolution(model: SolutionWithAnswersModel): Observable<GenericBaseApiResponse<StudentTestSolutionDataModel>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentTestSolutionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentTestSolutionService>;
}

/**
Методы контроллера Tutor.Api.Controllers.TestSolutions.StudentTestSolutionQueryController
BasePath = api/tutor/test-solution/query/mine
*/
declare class StudentTestSolutionQueryService {
    private readonly _httpClient;
    private readonly baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    search(model: SearchMyTestSolutionsRequest): rxjs.Observable<GetListResult<StudentTestSolutionWithChatInfo>>;
    getResultById(id: string): rxjs.Observable<GenericBaseApiResponse<StudentTestSolutionDataModel>>;
    getByTestId(testId: string): rxjs.Observable<TestWithActiveSolutionModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentTestSolutionQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentTestSolutionQueryService>;
}

declare class StudentGroupTestRelationQueryService {
    private readonly _httpClient;
    getBaseUrl(): string;
    private readonly _baseUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    getById(studentGroupId: string, testId: string): rxjs.Observable<StudentTestGroupRelationDetailedModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentGroupTestRelationQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentGroupTestRelationQueryService>;
}

declare class CuratorMessageTemplateService {
    private readonly _httpClient;
    getBaseControllerUrl(): string;
    private readonly _baseUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    createOrUpdate(model: CreateOrUpdateCuratorMessageTemplate): Observable<BaseApiResponse>;
    delete(model: DeleteCuratorMessageTemplate): Observable<BaseApiResponse>;
    search(model: SearchCuratorMessageTemplates): Observable<GetListResult<CuratorMessageTemplateModel>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CuratorMessageTemplateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CuratorMessageTemplateService>;
}

/**
 * Методы контроллера Tutor.Api.Controllers.Courses.CourseThemeItemStudentTestRestrictionController
 *
 * Предоставляет методы для работы с предупреждениями о наступающем дедлайне в курсе
 *
 * базовый путь = api/tutor/course-theme-item/test-restriction/student
 */
declare class CourseDeadlineWarningService {
    private _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    getStudentWarnings(model: GetStudentCourseThemeItemsDeadlineWarningsRequest): rxjs.Observable<CourseThemeItemStudentDeadlineWarningModel[]>;
    getStudentWarningsGrouped(model: GetStudentCourseThemeItemsDeadlineWarningsRequest): rxjs.Observable<CourseThemeIdWithDeadlineWarnings[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CourseDeadlineWarningService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CourseDeadlineWarningService>;
}

/**
 * Методы контроллера Tutor.Api.Controllers.Courses.CourseThemeItemTestRestrictionController
 *
 * Предоставляет методы для управления глобальными ограничениями теста для блока курса
 *
 * базовый путь = api/tutor/course-theme-item/test-restriction
 */
declare class CourseThemeItemTestRestrictionService {
    private readonly _http;
    private readonly baseControllerUrl;
    constructor(_http: HttpClient, baseUrl: string);
    setGlobal(model: CourseItemGlobalTestRestrictionModel): rxjs.Observable<BaseApiResponse>;
    getGlobal(id: string): rxjs.Observable<TestRestrictionModel>;
    removeAll(courseId: string): rxjs.Observable<BaseApiResponse>;
    startRemovingAll(courseId: string): rxjs.Observable<BaseApiResponse>;
    getRemovingAllState(courseId: string): rxjs.Observable<CourseRemovingAllTestRestrictionsState>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CourseThemeItemTestRestrictionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CourseThemeItemTestRestrictionService>;
}

/**
 * Методы контроллера Tutor.Api.Controllers.Subjects.SubjectQueryController
 *
 * Базовый урл = api/tutor/subject/query
 *
 * Методы для получения предметов
 */
declare class SubjectQueryService {
    private readonly _httpClient;
    private readonly _baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    getAll(): rxjs.Observable<SubjectModel[]>;
    getAllCached(): rxjs.Observable<SubjectModel[]>;
    getAllWithClarifications(): rxjs.Observable<SubjectWithClarificationsModel[]>;
    getAllWithClarificationsCached(): rxjs.Observable<SubjectWithClarificationsModel[]>;
    getByAliasOrId(id: string): rxjs.Observable<SubjectCountsModel>;
    getByAliasOrIdCached(idOrAlias: string): rxjs.Observable<SubjectCountsModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubjectQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SubjectQueryService>;
}

/**
 * Методы контроллера Tutor.Api.Controllers.Subjects.SubjectController
 *
 * Базовый урл = api/tutor/subject
 *
 * Методы для работы с предметами
 */
declare class SubjectsService {
    private readonly _httpClient;
    private readonly baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    create(model: CreateSubjectRequest): Observable<BaseApiResponse>;
    order(model: OrderSubjectsRequest): Observable<BaseApiResponse>;
    update(model: UpdateSubjectRequest): Observable<BaseApiResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubjectsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SubjectsService>;
}

/**
 * Методы контроллера Tutor.Api.Controllers.Courses.CourseThemeItemStudentTestRestrictionController
 *
 * Предоставляет методы для управления ограничениями теста для блока курса
 *
 * базовый путь = api/tutor/course-theme-item/test-restriction/student
 */
declare class CourseThemeItemTestRestrictionStudentService {
    private readonly _http;
    private baseControllerUrl;
    constructor(_http: HttpClient, baseUrl: string);
    updateForStudent(model: CourseItemStudentTestRestrictionModel): rxjs.Observable<BaseApiResponse>;
    getStudentRestriction(model: GetCourseThemeItemStudentTestRestrictionRequest): rxjs.Observable<TestRestrictionValidationResult>;
    getStudentRestrictionWithDeadLineWarning(model: GetCourseThemeItemStudentTestRestrictionRequest): rxjs.Observable<TestRestrictionValidationWithDeadLineWarningResult>;
    searchStudents(model: SearchStudentThemeItemTestRestrictionsRequest): rxjs.Observable<GetListResult<ThemeItemTestStudentRestrictionModel>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CourseThemeItemTestRestrictionStudentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CourseThemeItemTestRestrictionStudentService>;
}

/**
 * Предоставляет методы контроллера Tutor.Api.Controllers.Courses.StudentCourseViewController
 * Оптимизированные методы для работы студентов с курсами
 * Базовый урл = api/tutor/student-course-view
 */
declare class StudentCourseViewService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    /**
     * Запрос для получения решений тестов по блоку в теме курса и ограничения по количеству попыток и дедлайну. Метод кешируется на 30 секунд.
     * @param courseId - идентификатор курса
     * @param studentProgressId - идентификатор прогресса ученика
     * @param themeItemId - идентификатор блока тема внутри курса
     * @param solutionsCount - количество решений тестов
     * @param key - ключ для сброса кеширования
     * @returns
     */
    loadThemeItemSolutionsAndTestRestriction(courseId: string, studentProgressId: string, themeItemId: string, solutionsCount: number, key: string): Observable<CourseThemeItemsTestSolutionsRestrictionsModel[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentCourseViewService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentCourseViewService>;
}

/**
 * Предоставляет методы для поиска решений тестов
 */
declare class TestSolutionDetailedQueryService {
    private _httpClient;
    private _baseUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    /**
     *
     * @param id Идентификатор решения теста
     * @returns
     */
    get(id: string): Observable<StudentTestSolutionDetailedModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TestSolutionDetailedQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TestSolutionDetailedQueryService>;
}

/**
 * Предоставляет методы для работы с лендинг страницами для курса
 * Контроллер = Tutor.Api.Controllers.Landings.CourseLandingPageController
 */
declare class CourseLandingPageQueryService {
    private readonly _httpClient;
    private readonly _baseUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    /**
     * Поиск лендинг страниц
     * @param model
     * @returns
     */
    search(model: SearchCourseLandingPageRequest): rxjs.Observable<GetListResult<CourseLandingPageSimpleModel>>;
    /**
     * Получить лендинг страницу по идентификатору
     * @param id идентификатор страницы
     * @param useCache использовать кеш
     * @returns
     */
    getById(id: string, useCache: boolean): rxjs.Observable<CourseLandingPageDetailedModel>;
    private getByIdCached;
    static ɵfac: i0.ɵɵFactoryDeclaration<CourseLandingPageQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CourseLandingPageQueryService>;
}

/**
 * Предоставляем методы контроллера Tutor.Api.Controllers.Courses.CourseOrderController
 */
declare class CourseOrderService {
    private _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    /**
     * Получить заказ на покупку курса по идентификатору
     * @param id идентификатор заказа
     * @returns
     */
    getById(id: string): rxjs.Observable<CourseOrderModel>;
    /**
     * созать заказ на покупку курса
     * @param model запрос для создания заказа на покупку курса
     * @returns
     */
    create(model: CreateCourseOrderRequest): rxjs.Observable<CreateCourseOrderResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CourseOrderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CourseOrderService>;
}

declare class CourseShopWindowDetailedService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    getMain(): rxjs.Observable<CourseShopWindowDetailedModel>;
    getMainCached(): rxjs.Observable<CourseShopWindowDetailedModel>;
    getById(id: string): rxjs.Observable<CourseShopWindowDetailedModel>;
    getByIdCached(id: string): rxjs.Observable<CourseShopWindowDetailedModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CourseShopWindowDetailedService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CourseShopWindowDetailedService>;
}

/**
 * Предоставляет методы контроллера Tutor.Api.Controllers.StudentGroupPaymentPlans.StudentGroupPaymentPlanQueryController
 */
declare class StudentGroupPaymentPlanQueryService {
    private _httpClient;
    private _baseUrl;
    getBaseUrl(): string;
    constructor(_httpClient: HttpClient, _baseUrl: string);
    /**
     * Получить группу и глобальные планы оплаты с ней связанные
     * @param id идентификатор группы
     * @returns групп с планами оплаты
     */
    getPaymentPlans(id: string): Observable<StudentGroupPaymentPlansModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentGroupPaymentPlanQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentGroupPaymentPlanQueryService>;
}

/**
 * Сервис для предоставления публичной конфигурации по приложению
 */
declare class TutorAppConfigurationService {
    private readonly _http;
    static readonly VariableKey = "__Tutor.FullConfiguration";
    private baseControllerUrl;
    constructor(_http: HttpClient, baseUrl: string);
    /**
     * Получить конифгурацию из window
     * @returns
     */
    get(): TutorFullApplicationPublicOptions;
    /**
     * Получить конифгурацию из window
     * @returns
     */
    static getFromWindow(): TutorFullApplicationPublicOptions;
    set(value: TutorFullApplicationPublicOptions): void;
    getFromServerIfValueNotSet(): rxjs.Observable<TutorFullApplicationPublicOptions>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TutorAppConfigurationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TutorAppConfigurationService>;
}

declare class QuestionLikeService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    change(model: ChangeQuestionLike): Observable<BaseApiResponse>;
    getBySolutionId(id: string): Observable<QuestionIdWithLike[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<QuestionLikeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<QuestionLikeService>;
}

declare class StudentCourseProgressQueryService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    /**
     * Получить прогресс студента по курсу
     * @param courseId Идентификатор курса
     * @returns
     */
    getMine(courseId: string): rxjs.Observable<StudentCourseProgressModel>;
    search(model: SearchCourseProgressesRequest): rxjs.Observable<GetListResult<StudentCourseProgressWithStudentModel>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentCourseProgressQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentCourseProgressQueryService>;
}

/**
 * Сервис для прохождения курса учеником.
 */
declare class StudentCourseProgressService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    startTheme(model: StartCourseThemeRequest): rxjs.Observable<BaseApiResponse>;
    updateThemeProgress(model: UpdateStudentCourseThemeProgressRequest): rxjs.Observable<UpdateStudentCourseThemeProgressResult>;
    startTestForItemBlock(model: StartCourseThemeItemTestRequest): rxjs.Observable<StartCourseThemeItemTestResult>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentCourseProgressService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentCourseProgressService>;
}

declare class StudentGroupMaterialService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    getMaterials(model: SearchStudentGroupMaterialsRequest): Observable<GetListResult<StudentGroupWithMaterialsModel>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentGroupMaterialService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentGroupMaterialService>;
}

declare class CoursePaymentService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    add(model: AddCoursePaymentRequest): rxjs.Observable<AddCoursePaymentResult>;
    setPaymentSystem(model: SetPaymentSystemForCoursePayment): rxjs.Observable<BaseApiResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoursePaymentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoursePaymentService>;
}

declare class CoursePaymentQueryService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    getById(id: string): rxjs.Observable<StudentCoursePaymentModel>;
    getByPaymentId(id: string): rxjs.Observable<StudentCoursePaymentModel>;
    search(model: SearchStudentCoursePaymentsRequest): rxjs.Observable<GetListResult<StudentCoursePaymentModel>>;
    searchDetailed(model: SearchStudentCoursePaymentsRequest): rxjs.Observable<GetListResult<StudentCoursePaymentDetailedModel>>;
    getTypes(): rxjs.Observable<EnumValueTypeWithDescriptionStudentCoursePaymentType[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoursePaymentQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoursePaymentQueryService>;
}

declare class TestQuestionStatisticQueryService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    search(model: SearchTestQuestionErrorsStatisticRequest): rxjs.Observable<GetListResult<StudentTestQuestionStatisticDetailedModel>>;
    getState(): rxjs.Observable<QuestionStatisticComputingState>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TestQuestionStatisticQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TestQuestionStatisticQueryService>;
}

declare class StudentGroupCourseAccessService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    get(model: GetStudentGroupCourseAccessRequest): rxjs.Observable<StudentGroupCourseWithDetailedAccessModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentGroupCourseAccessService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentGroupCourseAccessService>;
}

declare class StudentRegistrationService {
    private readonly _httpClient;
    private readonly _baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    register(model: RegisterModel): rxjs.Observable<StudentRegistrationResult>;
    registerV2(model: RegisterStudentRequest): rxjs.Observable<StudentRegistrationResult>;
    demoRegistration(): rxjs.Observable<StudentRegistrationResult>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentRegistrationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentRegistrationService>;
}

declare class PmtSystemService {
    private readonly _http;
    private baseControllerUrl;
    constructor(_http: HttpClient, baseUrl: string);
    search(model: SearchPaymentSystemsRequest): rxjs.Observable<GetListResult<PaymentSystemModel>>;
    getEnabledSystemsCached(): rxjs.Observable<PaymentSystemModel[]>;
    getById(name: string): rxjs.Observable<PaymentSystemModel>;
    order(model: OrderPaymentSystemsRequest): rxjs.Observable<BaseApiResponse>;
    createOrUpdate(model: PaymentSystemModel): rxjs.Observable<BaseApiResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PmtSystemService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PmtSystemService>;
}

declare class DefaultCourseLandingPageQueryService {
    private readonly _httpClient;
    private readonly _baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    getById(id: string): rxjs.Observable<DefaultCourseLandingPageModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultCourseLandingPageQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultCourseLandingPageQueryService>;
}

declare class StudentGroupInfoPageService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    get(model: GetStudentGroupInfoPageRequest): Observable<StudentGroupInfoPageDetailedModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentGroupInfoPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentGroupInfoPageService>;
}

declare class StudentAggregatedStatisticSnapshotService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    get(studentId: string): rxjs.Observable<StudentStatisticSnapshotValueModel>;
    getDebugInfo(studentId: string): rxjs.Observable<StudentStatisticSnapshotValueDebugInfoModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentAggregatedStatisticSnapshotService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentAggregatedStatisticSnapshotService>;
}

declare class GroupStatisticSnapshotStudentService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    /**
     *
     * @param model запрос для получения снапшота агрегированной статистики ученика по предметам и тегам в рамках группы (курса)
     * @returns
     */
    get(model: GetStudentInGroupStatisticSnapshotRequest): rxjs.Observable<StudentInGroupStatisticSnapshotModel>;
    /**
     * Получить информацию о снапшоте.
     * @param id идентификатор снепшота
     * @returns
     */
    getSnapshotInfo(id: string): rxjs.Observable<StudentGroupStatisticSnapshotInfoModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupStatisticSnapshotStudentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GroupStatisticSnapshotStudentService>;
}

/**
 * Методы контроллера Tutor.Api.Controllers.Subjects.SubjectMenuController
 *
 * Базовый урл = api/tutor/subject/menu
 *
 * Методы для работы с меню предмета
 */
declare class SubjectMenuService {
    private readonly _httpClient;
    private readonly baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    create(model: CreateSubjectMenuRequest): rxjs.Observable<BaseApiResponse$1>;
    getMain(): rxjs.Observable<SubjectMenuSimpleModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubjectMenuService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SubjectMenuService>;
}

declare class TutorUserTelegramService {
    private readonly _httpClient;
    baseControllerUrl: string;
    constructor(_httpClient: HttpClient, baseUrl: string);
    createLink(): rxjs.Observable<GenericBaseApiResponse$1<TelegramLinkResponse>>;
    unLink(id: string): rxjs.Observable<BaseApiResponse$1>;
    getData(): rxjs.Observable<TutorUserTelegramData>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TutorUserTelegramService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TutorUserTelegramService>;
}

declare class StudentGroupBlockService {
    private readonly _httpClient;
    private readonly _baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    setDate(model: StudentInGroupSetBlockingDateModel): rxjs.Observable<BaseApiResponse>;
    setState(model: StudentInGroupSetBlockingModel): rxjs.Observable<BaseApiResponse>;
    getMineV2(model: GetMyStudentGroupBlockRequest): rxjs.Observable<StudentInGroupWithBlockModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StudentGroupBlockService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StudentGroupBlockService>;
}

/**
 * Роли для модуля Tutor
 */
declare class TutorRoles {
    /**
     * Куратор - проверяет домашние задания студентов (учеников).
     */
    static readonly curator: string;
    /**
     * Администратор - управляет и настраивает платформу
     */
    static readonly admin: string;
    /**
     * Студент (ученик) - проходит курсы, решает тесты, просматривает материалы.
     */
    static readonly student: string;
    /**
     * Пользователь, который может вносить вопросы
     */
    static readonly testAuthor: string;
    /**
     * Администратор конкретной школы
     */
    static readonly schoolAdmin: string;
}

declare class ImageSrcExtensions {
    /**
     * Вовзращает полный путь к изображению по идентификатору файла и типу размера изображения
     * @param publicImageUrlFormat Форматированная строка содержащая {fileId} и {sizeType} для замены
     * @param imageFileId Идентификатор изображения
     * @param imageType Тип изображения
     * @returns
     */
    static createImagePath(publicImageUrlFormat: string, imageFileId: number | string, sizeType?: string): string | null;
}

export { AnswerValidationResultType, CourseDeadlineWarningService, CourseLandingPageQueryService, CourseOrderService, CoursePaymentQueryService, CoursePaymentService, CourseShopWindowDetailedService, CourseThemeItemTestRestrictionService, CourseThemeItemTestRestrictionStudentService, CuratorMessageTemplateService, DefaultCourseLandingPageQueryService, GapType, GroupStatisticSnapshotStudentService, ImageSrcExtensions, OpenApiQuestionLikeService, OpenApiTestSolutionService, PmtSystemService, QuestionLikeService, QuestionValidationSourceType, SelectRightAnswerOrAnswersQuestionDataItemType, StudentAggregatedStatisticSnapshotService, StudentCoursePaymentType, StudentCourseProgressQueryService, StudentCourseProgressService, StudentCourseViewService, StudentGroupBlockService, StudentGroupCourseAccessService, StudentGroupEnterService, StudentGroupInfoPageService, StudentGroupMaterialService, StudentGroupPaymentPlanQueryService, StudentGroupQueryService, StudentGroupTaskType, StudentGroupTestRelationQueryService, StudentGroupType, StudentQueryService, StudentRegistrationService, StudentTestSolutionQueryService, StudentTestSolutionService, StudentTestSolutionStartService, SubjectMenuService, SubjectQueryService, SubjectsService, TestQuestionErrorsStatisticOrderType, TestQuestionStatisticQueryService, TestQuestionType, TestRestrictionValidationResultRuleType, TestService, TestSolutionDetailedQueryService, TestSolutionQueryService, TestSolutionResultService, TutorAppConfigurationService, TutorLogicModule, TutorRoles, TutorUserTelegramService };
export type { AddCoursePaymentRequest, AddCoursePaymentResult, Answer, BaseApiResponse, ChangeQuestionLike, CmsBooleanProperty, CmsButton, CmsPageBlockModel, CmsPageButton, CmsPageModel, CmsPageNavigationItem, CmsPropertiesModel, CmsStringProperty, ComputedStatisticPresentationModel, CourseDetailedModel, CourseItemGlobalTestRestrictionModel, CourseItemStudentTestRestrictionModel, CourseLandingPageDetailedModel, CourseLandingPageSimpleModel, CourseOrderModel, CourseRemovingAllTestRestrictionsState, CourseRemovingAllTestRestrictionsStateModel, CourseShopWindowDetailedModel, CourseShopWindowItemCardOptionsModel, CourseShopWindowItemDetailedModel, CourseShopWindowItemModel, CourseSimpleModel, CourseThemeDetailedModel, CourseThemeIdWithDeadlineWarnings, CourseThemeItemModel, CourseThemeItemStudentDeadlineWarningModel, CourseThemeItemTestModel, CourseThemeItemUISettingsModel, CourseThemeItemsTestSolutionsRestrictionsModel, CreateCourseOrderRequest, CreateCourseOrderResponse, CreateOrUpdateCuratorMessageTemplate, CreateSubjectMenuRequest, CreateSubjectRequest, CreateTestForStudentErrorsRequest, CreateTestRequest, CrocoHtmlLinkTagCustomIconOptions, CuratorMessageTemplateModel, DeadLineWithWarningMessage, DefaultCourseLandingDisplayOptions, DefaultCourseLandingPageModel, DeleteCuratorMessageTemplate, DemoPaymentDescription, EditTestRequest, EnterGroupResponse, EnumValueTypeWithDescriptionStudentCoursePaymentType, GapModel, GapsQuestionData, GenericBaseApiResponse, GetCourseThemeItemStudentTestRestrictionRequest, GetListResult, GetMyStudentGroupBlockRequest, GetStudentCourseThemeItemsDeadlineWarningsRequest, GetStudentGroupCourseAccessRequest, GetStudentGroupInfoPageRequest, GetStudentInGroupStatisticSnapshotRequest, GetToGroupByCodeRequest, IconApplicationSettings, IconApplicatonSettings, IconSimpleModel$1 as IconSimpleModel, MainTelegramBotSettings, ManyAnswersBoxesQuestionData, MultiSchoolOptions, OrderPaymentSystemsRequest, OrderSubjectsRequest, PaymentSystemModel, ProgressModel, QuestionAnswer, QuestionAnswerBox, QuestionAnswerWithResult, QuestionIdWithLike, QuestionInSolutionIdModel, QuestionPointsValidationModel, QuestionStatisticComputingState, QuestionsFilter, RegisterModel, RegisterStudentRequest, RegisteredUser, SaveQuestionPointsValidation, SearchCourseLandingPageRequest, SearchCourseProgressesRequest, SearchCuratorMessageTemplates, SearchMyTestSolutionsRequest, SearchPaymentSystemsRequest, SearchQuestionsByLikes, SearchStudentCoursePaymentsRequest, SearchStudentGroupMaterialsRequest, SearchStudentGroupsByStudentRequest, SearchStudentGroupsRequest, SearchStudentTestSolutionsRequest, SearchStudentThemeItemTestRestrictionsRequest, SearchStudentsInGroup, SearchStudentsRequest, SearchTestQuestionErrorsStatisticRequest, SearchTestsRequest, SelectRightAnswerOrAnswersQuestionData, SetPaymentSystemForCoursePayment, SolutionMarketingOptions, SolutionWithAnswerModel, SolutionWithAnswersModel, StartCourseThemeItemTestRequest, StartCourseThemeItemTestResult, StartCourseThemeRequest, StartSolutionFromDirectoryRequest, StartTestSolutionByTestIdRequest, StudentCourseItemTestSolution, StudentCourseItemTestSolutionValidationModel, StudentCoursePaymentDetailedModel, StudentCoursePaymentModel, StudentCourseProgressModel, StudentCourseProgressWithStudentModel, StudentCourseThemeProgressItemModel, StudentCourseThemeProgressModel, StudentDemoSettings, StudentGroupAccessProlongationNotification, StudentGroupCourseProgressSimpleModel, StudentGroupCourseWithDetailedAccessModel, StudentGroupDetailedModel, StudentGroupGlobalPaymentPlanModel, StudentGroupInfoPageDetailedModel, StudentGroupInfoPageDetailedStudentAccessModel, StudentGroupPaymentPlanSimpleModel, StudentGroupPaymentPlansModel, StudentGroupSimpleModel, StudentGroupStatisticSnapshotInfoModel, StudentGroupTaskInfo, StudentGroupWithCourseProgressModel, StudentGroupWithMaterialsModel, StudentGroupWithPaymentPlansModel, StudentInGroupSetBlockingDateModel, StudentInGroupSetBlockingModel, StudentInGroupSimpleModel, StudentInGroupStatisticBySubjectSnapshotValueModel, StudentInGroupStatisticByTagSnapshotValueModel, StudentInGroupStatisticSnapshotModel, StudentInGroupWithBlockModel, StudentRegistrationResult, StudentSimpleModel, StudentStatisticSnapshotSubjectValueModel, StudentStatisticSnapshotTagValueModel, StudentStatisticSnapshotValueDebugInfoModel, StudentStatisticSnapshotValueModel, StudentTestGroupRelationDetailedModel, StudentTestQuestionStatisticDetailedModel, StudentTestSolutionDataModel, StudentTestSolutionDetailedModel, StudentTestSolutionDetailedTestModel, StudentTestSolutionDetailedTestQuestion, StudentTestSolutionModel, StudentTestSolutionSimpleModel, StudentTestSolutionWithChatInfo, StudentTestSolutionWithStudentAndChatInfo, SubjectCountsModel, SubjectMenuSimpleModel, SubjectMenuWithIconsModel, SubjectModel, SubjectWithClarificationsModel, SubjectWithIconModel, TelegramLinkResponse, TelephoneInputOptions, TestModel, TestQuestionModel, TestQuestionModiferModel, TestQuestionWithModifiers, TestRestrictionModel, TestRestrictionValidationResult, TestRestrictionValidationWithDeadLineWarningResult, TestSolutionCourseData, TestSolutionCreatedResult, TestSolutionSystemValidationModel, TestSolutionWithPointsValidation, TestWithActiveSolutionModel, ThemeItemTestStudentRestrictionModel, TutorFullApplicationPublicOptions, TutorImagesPackSettings, TutorUserTelegramData, TypeAnswerWithErrorsQuestionData, TypeRightAnswerQuestionData, UpdateStudentCourseThemeProgressRequest, UpdateStudentCourseThemeProgressResult, UpdateSubjectRequest, UserAgreementsOptions, WebAppRoutes };