{"version":3,"file":"main.78e15fafaa820f0e.js","mappings":"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A,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,kBACA,eACA,kBACA,eACA,YACA,eACA,YACA,eACA,eACA,kBACA,eACA,kBACA,eACA,kBACA,cACA,iBACA,eACA,kBACA,cACA,iBACA,eACA,kBACA,eACA,kBACA,YACA,eACA,YACA,eACA,kBACA,eACA,kBACA,eACA,kBACA,eACA,YACA,eACA,WACA,cACA,YACA,eACA,YACA,eACA,aACA,gBACA,YACA,eACA,YACA,eACA,kBACA,eACA,kBACA,eACA,WACA,cACA,YACA,eACA,YACA,eACA,YACA,eACA,kBACA,qBACA,kBACA,qBACA,YACA,eACA,YACA,eACA,WACA,cACA,WACA,cACA,YACA,eACA,eACA,kBACA,YACA,eACA,YACA,eACA,YACA,eACA,kBACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,WACA,cACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,UACA,aACA,YACA,eACA,YACA,eACA,YACA,eACA,WACA,cACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,kBACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,YACA,eACA,WACA,eACA,kBACA,cACA,YACA,eACA,eACA,kBACA,cACA,iBACA,YACA,eACA,YACA,eACA,kBACA,eACA,YACA,eACA,YACA,eACA,WACA,cACA,YACA,eACA,YACA,eACA,YACA,eACA,WACA,cACA,YACA,eACA,YACA,iBACA,oBACA,eACA,YACA,eACA,WACA,cACA,YACA,eACA,YACA,eACA,YACA,eACA,aACA,gBACA,YACA,eACA,YACA,eACA,YACA,eACA,eACA,kBACA,aACA,gBACA,YACA,eACA,aACA,gBACA,YACA,kBACA,qBACA,eACA,cACA,iBACA,YACA,eACA,YACA,eACA,YACA,iBACA,oBACA,eACA,YACA,eACA,kBACA,qBACA,YACA,eACA,eACA,kBACA,eACA,kBACA,eACA,kBACA,eACA,mBAIA,cACA,WACA,WACA,CACA,cACA,cACA,8CACA,gCACAkJ,EAEA,WACA,CACAC,kBACA,qBACA,EACAA,YACAC,YACAD","names":["GlobalStorageService","constructor","store","getGridFilters","currentFilters","localStorage","getItem","JSON","parse","setGridFilters","formValues","setItem","stringify","getGridColumns","grid","setGridColums","columns","setToken","token","getToken","setUser","user","getUser","userStorage","updateStudentCurrentStepAndDispatchToStore","student","step","updates","currentStep","stepNumber","currentStepId","id","currentStepStatus","status","this","dispatch","StudentActions","updateThesisDocumentsAndDispatchToStore","currentStudent","updatedDocuments","thesis","documents","updateConventionAndDispatchToStore","convention","updateThesisAndDispatchToStore","core","factory","ApiConfiguration","BaseService","config","http","rootUrl","_rootUrl","_angular_core__WEBPACK_IMPORTED_MODULE_0__","EnumStepStatus","ParameterCodecInstance","ParameterCodec","encodeKey","key","encodeURIComponent","encodeValue","value","decodeKey","decodeURIComponent","decodeValue","Parameter","name","options","defaultStyle","defaultExplode","style","explode","serializeValue","separator","Array","map","v","split","join","array","Object","keys","propVal","push","String","PathParameter","super","append","path","prefix","alreadySerialized","replace","result","QueryParameter","params","HeaderParameter","headers","RequestBuilder","operationPath","method","Map","_path","set","query","_query","header","_header","body","contentType","_bodyContentType","Blob","type","pairs","val","formValue","formDataValue","_bodyContent","p","formData","FormData","toAppend","build","pathParam","values","url","httpParams","HttpParams","encoder","queryParam","httpHeaders","HttpHeaders","accept","headerParam","HttpRequest","toUpperCase","responseType","reportProgress","context","AnswersService","createAnswerAsync$Plain$Response","rb","CreateAnswerAsyncPath","request","pipe","filter","r","HttpResponse","createAnswerAsync$Plain","createAnswerAsync$Response","createAnswerAsync","updateAnswerAsync$Plain$Response","UpdateAnswerAsyncPath","answerId","updateAnswerAsync$Plain","updateAnswerAsync$Response","updateAnswerAsync","_angular_core__WEBPACK_IMPORTED_MODULE_5__","CampusService","getAllCampusAsync$Plain$Response","GetAllCampusAsyncPath","getAllCampusAsync$Plain","getAllCampusAsync$Response","getAllCampusAsync","CommentsService","updateCommentByIdAsync$Plain$Response","UpdateCommentByIdAsyncPath","commentId","updateCommentByIdAsync$Plain","updateCommentByIdAsync$Response","updateCommentByIdAsync","commentsPost$Plain$Response","CommentsPostPath","commentsPost$Plain","commentsPost$Response","commentsPost","ConventionsService","getConventionByIdAsync$Plain$Response","GetConventionByIdAsyncPath","conventionId","getConventionByIdAsync$Plain","getConventionByIdAsync$Response","getConventionByIdAsync","createConventionAsync$Plain$Response","CreateConventionAsyncPath","createConventionAsync$Plain","createConventionAsync$Response","createConventionAsync","updateConventionByIdAsync$Plain$Response","UpdateConventionByIdAsyncPath","updateConventionByIdAsync$Plain","updateConventionByIdAsync$Response","updateConventionByIdAsync","deleteConventionByIdAsync$Plain$Response","DeleteConventionByIdAsyncPath","clone","deleteConventionByIdAsync$Plain","deleteConventionByIdAsync$Response","deleteConventionByIdAsync","CoordinatorCommentsService","createCoordinatorCommentAsync$Plain$Response","CreateCoordinatorCommentAsyncPath","createCoordinatorCommentAsync$Plain","createCoordinatorCommentAsync$Response","createCoordinatorCommentAsync","updateCoordinatorCommentAsync$Plain$Response","UpdateCoordinatorCommentAsyncPath","coordinatorCommentId","updateCoordinatorCommentAsync$Plain","updateCoordinatorCommentAsync$Response","updateCoordinatorCommentAsync","getCoordinatorCommentsByThesisIdAsync$Plain$Response","GetCoordinatorCommentsByThesisIdAsyncPath","thesisId","getCoordinatorCommentsByThesisIdAsync$Plain","getCoordinatorCommentsByThesisIdAsync$Response","getCoordinatorCommentsByThesisIdAsync","deleteCoordinatorCommentAsync$Plain$Response","DeleteCoordinatorCommentAsyncPath","idComment","deleteCoordinatorCommentAsync$Plain","deleteCoordinatorCommentAsync$Response","deleteCoordinatorCommentAsync","CountriesService","getAllCountriesAsync$Plain$Response","GetAllCountriesAsyncPath","getAllCountriesAsync$Plain","getAllCountriesAsync$Response","getAllCountriesAsync","DocumentsService","createDocumentAsync$Plain$Response","CreateDocumentAsyncPath","createDocumentAsync$Plain","createDocumentAsync$Response","createDocumentAsync","deleteDocumentAsync$Plain$Response","DeleteDocumentAsyncPath","documentId","deleteDocumentAsync$Plain","deleteDocumentAsync$Response","deleteDocumentAsync","getDocumentsByThesisAndTypeAsync$Plain$Response","GetDocumentsByThesisAndTypeAsyncPath","getDocumentsByThesisAndTypeAsync$Plain","getDocumentsByThesisAndTypeAsync$Response","getDocumentsByThesisAndTypeAsync","createDocumentByThesisAndTypeAsync$Plain$Response","CreateDocumentByThesisAndTypeAsyncPath","createDocumentByThesisAndTypeAsync$Plain","createDocumentByThesisAndTypeAsync$Response","createDocumentByThesisAndTypeAsync","ExaminationAnswersService","createExaminationAnswerAsync$Plain$Response","CreateExaminationAnswerAsyncPath","createExaminationAnswerAsync$Plain","createExaminationAnswerAsync$Response","createExaminationAnswerAsync","updateExaminationAnswerByIdAsync$Plain$Response","UpdateExaminationAnswerByIdAsyncPath","examinationAnswerId","updateExaminationAnswerByIdAsync$Plain","updateExaminationAnswerByIdAsync$Response","updateExaminationAnswerByIdAsync","ExaminationQuestionCategoriesService","getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Plain$Response","GetAllExaminationQuestionCategoriesBySpecialisationAndProgramAsyncPath","specialisationId","programCode","getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Plain","getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Response","getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync","ExaminationQuestionsService","getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Plain$Response","GetAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsyncPath","examinationId","questionCategoryId","getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Plain","getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Response","getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync","ExaminationsService","createExaminationAsync$Plain$Response","CreateExaminationAsyncPath","createExaminationAsync$Plain","createExaminationAsync$Response","createExaminationAsync","updateExaminationByIdAsync$Plain$Response","UpdateExaminationByIdAsyncPath","updateExaminationByIdAsync$Plain","updateExaminationByIdAsync$Response","updateExaminationByIdAsync","HistoricsService","getAllHistoricsByThesisIdAsync$Plain$Response","GetAllHistoricsByThesisIdAsyncPath","getAllHistoricsByThesisIdAsync$Plain","getAllHistoricsByThesisIdAsync$Response","getAllHistoricsByThesisIdAsync","ProfessorsService","getProfessorConnectedAsync$Plain$Response","GetProfessorConnectedAsyncPath","getProfessorConnectedAsync$Plain","getProfessorConnectedAsync$Response","getProfessorConnectedAsync","getProfessorsBySectorIdAsync$Plain$Response","GetProfessorsBySectorIdAsyncPath","sectorId","getProfessorsBySectorIdAsync$Plain","getProfessorsBySectorIdAsync$Response","getProfessorsBySectorIdAsync","getSupervisorsByLastNameAsync$Plain$Response","GetSupervisorsByLastNameAsyncPath","lastName","getSupervisorsByLastNameAsync$Plain","getSupervisorsByLastNameAsync$Response","getSupervisorsByLastNameAsync","getSupervisorsAndCoSupervisorsByLastNameAsync$Plain$Response","GetSupervisorsAndCoSupervisorsByLastNameAsyncPath","getSupervisorsAndCoSupervisorsByLastNameAsync$Plain","getSupervisorsAndCoSupervisorsByLastNameAsync$Response","getSupervisorsAndCoSupervisorsByLastNameAsync","getProfessorInformationsByIdAsync$Plain$Response","GetProfessorInformationsByIdAsyncPath","professorId","getProfessorInformationsByIdAsync$Plain","getProfessorInformationsByIdAsync$Response","getProfessorInformationsByIdAsync","ProjectsService","getAllProjectsAsync$Plain$Response","GetAllProjectsAsyncPath","getAllProjectsAsync$Plain","getAllProjectsAsync$Response","getAllProjectsAsync","QuestionCategoriesService","getQuestionCategoriesByStudentIdAsync$Plain$Response","GetQuestionCategoriesByStudentIdAsyncPath","studentId","getQuestionCategoriesByStudentIdAsync$Plain","getQuestionCategoriesByStudentIdAsync$Response","getQuestionCategoriesByStudentIdAsync","QuestionsService","getQuestionsAndAnswersByStudentAndCategoryIdAsync$Plain$Response","GetQuestionsAndAnswersByStudentAndCategoryIdAsyncPath","getQuestionsAndAnswersByStudentAndCategoryIdAsync$Plain","getQuestionsAndAnswersByStudentAndCategoryIdAsync$Response","getQuestionsAndAnswersByStudentAndCategoryIdAsync","SemestersService","getCurrentSemesterBySpecialisationAndProjectIdAsync$Plain$Response","GetCurrentSemesterBySpecialisationAndProjectIdAsyncPath","projectId","getCurrentSemesterBySpecialisationAndProjectIdAsync$Plain","getCurrentSemesterBySpecialisationAndProjectIdAsync$Response","getCurrentSemesterBySpecialisationAndProjectIdAsync","getSemesterByIdAsync$Plain$Response","GetSemesterByIdAsyncPath","semesterId","getSemesterByIdAsync$Plain","getSemesterByIdAsync$Response","getSemesterByIdAsync","updateSemesterByIdAsync$Plain$Response","UpdateSemesterByIdAsyncPath","updateSemesterByIdAsync$Plain","updateSemesterByIdAsync$Response","updateSemesterByIdAsync","searchSemestersBySpecialisationAndProjectIdAsync$Plain$Response","SearchSemestersBySpecialisationAndProjectIdAsyncPath","searchSemestersBySpecialisationAndProjectIdAsync$Plain","searchSemestersBySpecialisationAndProjectIdAsync$Response","searchSemestersBySpecialisationAndProjectIdAsync","SpecialisationsService","getAllSpecialisationsAsync$Plain$Response","GetAllSpecialisationsAsyncPath","getAllSpecialisationsAsync$Plain","getAllSpecialisationsAsync$Response","getAllSpecialisationsAsync","StepTypesService","getAllStepTypesBySpecialisationIdAsync$Plain$Response","GetAllStepTypesBySpecialisationIdAsyncPath","getAllStepTypesBySpecialisationIdAsync$Plain","getAllStepTypesBySpecialisationIdAsync$Response","getAllStepTypesBySpecialisationIdAsync","StepsService","createStepAsync$Plain$Response","CreateStepAsyncPath","createStepAsync$Plain","createStepAsync$Response","createStepAsync","updateStepAsync$Plain$Response","UpdateStepAsyncPath","stepId","updateStepAsync$Plain","updateStepAsync$Response","updateStepAsync","validateStepAndNextAsync$Plain$Response","ValidateStepAndNextAsyncPath","validateStepAndNextAsync$Plain","validateStepAndNextAsync$Response","validateStepAndNextAsync","StudentsService","getStudentConnectedAsync$Plain$Response","GetStudentConnectedAsyncPath","getStudentConnectedAsync$Plain","getStudentConnectedAsync$Response","getStudentConnectedAsync","searchStudentsLastNameBeginsWithAsync$Plain$Response","SearchStudentsLastNameBeginsWithAsyncPath","searchStudentsLastNameBeginsWithAsync$Plain","searchStudentsLastNameBeginsWithAsync$Response","searchStudentsLastNameBeginsWithAsync","getStudentInformationsById$Plain$Response","GetStudentInformationsByIdPath","getStudentInformationsById$Plain","getStudentInformationsById$Response","getStudentInformationsById","SupervisionsService","createSupervisionAsync$Plain$Response","CreateSupervisionAsyncPath","createSupervisionAsync$Plain","createSupervisionAsync$Response","createSupervisionAsync","updateSupervisionByIdAsync$Plain$Response","UpdateSupervisionByIdAsyncPath","supervisionId","updateSupervisionByIdAsync$Plain","updateSupervisionByIdAsync$Response","updateSupervisionByIdAsync","SupervisorsService","documentStepValidationAsync$Plain$Response","DocumentStepValidationAsyncPath","documentStepValidationAsync$Plain","documentStepValidationAsync$Response","documentStepValidationAsync","documentsPciStepValidationAsync$Plain$Response","DocumentsPciStepValidationAsyncPath","documentsPciStepValidationAsync$Plain","documentsPciStepValidationAsync$Response","documentsPciStepValidationAsync","deleteStepCommentAsync$Plain$Response","DeleteStepCommentAsyncPath","deleteStepCommentAsync$Plain","deleteStepCommentAsync$Response","deleteStepCommentAsync","getThesisSupervisorByIdAsync$Plain$Response","GetThesisSupervisorByIdAsyncPath","getThesisSupervisorByIdAsync$Plain","getThesisSupervisorByIdAsync$Response","getThesisSupervisorByIdAsync","getAllThesisBySupervisorIdAsync$Plain$Response","GetAllThesisBySupervisorIdAsyncPath","supervisorId","getAllThesisBySupervisorIdAsync$Plain","getAllThesisBySupervisorIdAsync$Response","getAllThesisBySupervisorIdAsync","updateExaminationSupervisorCoordinatorByIdAsync$Plain$Response","UpdateExaminationSupervisorCoordinatorByIdAsyncPath","updateExaminationSupervisorCoordinatorByIdAsync$Plain","updateExaminationSupervisorCoordinatorByIdAsync$Response","updateExaminationSupervisorCoordinatorByIdAsync","ThesisService","createThesisAsync$Plain$Response","CreateThesisAsyncPath","createThesisAsync$Plain","createThesisAsync$Response","createThesisAsync","updateThesisStep1Async$Plain$Response","UpdateThesisStep1AsyncPath","updateThesisStep1Async$Plain","updateThesisStep1Async$Response","updateThesisStep1Async","updateThesisStep4Async$Plain$Response","UpdateThesisStep4AsyncPath","updateThesisStep4Async$Plain","updateThesisStep4Async$Response","updateThesisStep4Async","getAllThesis$Plain$Response","GetAllThesisPath","getAllThesis$Plain","getAllThesis$Response","getAllThesis","getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain$Response","GetThesisDetailsSupervisionCoordinatorByThesisIdAsyncPath","getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain","getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Response","getThesisDetailsSupervisionCoordinatorByThesisIdAsync","updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain$Response","UpdateThesisDetailsSupervisionCoordinatorByThesisIdAsyncPath","updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain","updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Response","updateThesisDetailsSupervisionCoordinatorByThesisIdAsync","i0","ButtonComponent","EventEmitter","emitClick","clickCallbackFn","emit","selectors","ProfileLoaderComponent","AutoUnsubscribe","originalOnDestroy","prototype","ngOnDestroy","prop","hasOwnProperty","call","property","unsubscribe","apply","Roles","Specialisation","NotificationService","_snackBar","translateService","horizontalPosition","verticalPosition","error","message","open","instant","undefined","panelClass","duration","configuration","success","defaultDuration","info","MaterialModule","provide","MAT_DATE_LOCALE","useValue","MatDialogRef","imports","MatChipsModule","MatRippleModule","MatButtonToggleModule","MatRadioModule","MatStepperModule","MatSnackBarModule","MatTabsModule","MatProgressBarModule","MatCardModule","MatCheckboxModule","MatMenuModule","MatIconModule","MatSelectModule","MatDatepickerModule","MatMomentDateModule","MatFormFieldModule","MatInputModule","MatDialogModule","MatButtonModule","MatTableModule","MatSortModule","MatPaginatorModule","MatTreeModule","CdkAccordionModule","MatTooltipModule","MatAutocompleteModule","MatProgressSpinnerModule","SharedModule","CommonModule","FormsModule","ReactiveFormsModule","TranslateModule","UnauthorizedComponent","AuthenticationService","instance","location","hash","pop","redirectHash","acquireTokenPopup","from","acquireTokenRedirect","acquireTokenSilent","silentRequest","getAllAccounts","logoutRedirect","logout","logoutRequest","MSAL_INSTANCE","isIE","window","navigator","userAgent","indexOf","environment","production","mode","baseUri","apiUri","authentication","clientId","redirectUri","authority","postLogoutRedirectUri","navigateToLoginRequestUrl","appInsights","instrumentationKey","cache","cacheLocation","BrowserCacheLocation","storeAuthStateInCookie","scope","MonitoringService","ApplicationInsights","enableCorsCorrelation","disableTelemetry","enableAutoRouteTracking","loadAppInsights","logPageView","trackPageView","uri","logEvent","properties","trackEvent","logMetric","average","trackMetric","logException","exception","severityLevel","trackException","logTrace","trackTrace","UsersService","getUserAsync$Plain$Response","GetUserAsyncPath","getUserAsync$Plain","getUserAsync$Response","getUserAsync","SUPERVISOR_ROLES","COORDINATOR_ROLES","RolesGuard","route","_2","userStore","inject","Store","router","Router","select","userReducer","goingToStudentPages","routeConfig","goingToSupervisorPages","goingToCoordinatorPages","userRoles","roles","a","userRole","canActivateStudentPages","canActivateStudent","find","role","length","canActivateSupervisorPages","canActivateSupervisor","includes","some","canActivateCoordinatorPages","canActivateCoordinator","parseUrl","CoordinatorsService","getCoordinatorConnectedAsync$Plain$Response","GetCoordinatorConnectedAsyncPath","getCoordinatorConnectedAsync$Plain","getCoordinatorConnectedAsync$Response","getCoordinatorConnectedAsync","AuthGuard","state","broadcastService","MsalBroadcastService","authenticationService","monitoringService","usersService","globalStorageService","studentsService","professorsService","coordinatorsService","studentStore","supervisorStore","coordinatorStore","inProgress$","InteractionStatus","take","switchMap","account","checkUser","of","forkJoin","_","getUserRole","saveStudent","saveSupervisor","professor","SupervisorActions","saveCoordinator","coordinator","CoordinatorActions","scopes","accessToken","tap","UserActions","routes","component","title","canActivate","MsalGuard","loadChildren","Promise","then","SupervisorModule","CoordinatorModule","StudentModule","redirectTo","AppRoutingModule","RouterModule","initialNavigation","BrowserUtils","ArbitrationsService","getArbitrationByIdAsync$Plain$Response","GetArbitrationByIdAsyncPath","arbitrationId","getArbitrationByIdAsync$Plain","getArbitrationByIdAsync$Response","getArbitrationByIdAsync","updateArbitrationByIdAsync$Plain$Response","UpdateArbitrationByIdAsyncPath","updateArbitrationByIdAsync$Plain","updateArbitrationByIdAsync$Response","updateArbitrationByIdAsync","createArbitrationAsync$Plain$Response","CreateArbitrationAsyncPath","createArbitrationAsync$Plain","createArbitrationAsync$Response","createArbitrationAsync","ImportAurionService","importAurionGet$Plain$Response","ImportAurionGetPath","importAurionGet$Plain","importAurionGet$Response","importAurionGet","SectorsService","getAllSectorsAsync$Plain$Response","GetAllSectorsAsyncPath","getAllSectorsAsync$Plain","getAllSectorsAsync$Response","getAllSectorsAsync","TestModesService","testModeStudentSwitchSpecialisationAsync$Plain$Response","TestModeStudentSwitchSpecialisationAsyncPath","specialisationCode","testModeStudentSwitchSpecialisationAsync$Plain","testModeStudentSwitchSpecialisationAsync$Response","testModeStudentSwitchSpecialisationAsync","testModeDeleteThesisByIdAsync$Plain$Response","TestModeDeleteThesisByIdAsyncPath","testModeDeleteThesisByIdAsync$Plain","testModeDeleteThesisByIdAsync$Response","testModeDeleteThesisByIdAsync","LanguageSwitchComponent","translate","ngOnInit","frIcon","ukIcon","changeLanguage","document","documentElement","lang","language","defaultIsSelected","use","ctx","ProfileMenuComponent","_class","Subscription","getUserSubscribe","add","firstName","fullName","initials","charAt","userExist","loading","subscribe","tslib_es6","HeaderComponent","headerSubscription","coordinatorMode","supervisorMode","studentMode","getStudent","specialisation","studentSpecialisation","gotoPage","item","navigate","toLowerCase","goHome","AppComponent","app_component_class","stepsService","testModesService","currentEnv","testMode","subscription","currentUser","studentReducer","validateStep","reloadStep","reload","deleteThesis","refuseStep","stepStatus","switchSpecialization","operationResult","setTimeout","MsalInterceptor","msalInterceptorConfig","authService","intercept","req","next","getScopesForEndpoint","catchError","interactionType","InteractionType","authRequest","redirectStartPage","href","EMPTY","requestClone","handle","endpoint","keyMatchesEndpointArray","protectedResourceMap","Minimatch","match","keyForEndpoint","get","MSAL_INTERCEPTOR_CONFIG","AuthenticationModule","HTTP_INTERCEPTORS","useClass","multi","useFactory","PublicClientApplication","auth","MSAL_GUARD_CONFIG","MsalService","MsalModule","appReducer","userState","thesisSupervisorState","thesisSupervisorReducer","studentState","thesisTimelineState","thesisTimelineReducer","supervisorState","supervisorReducer","coordinatorState","coordinatorReducer","CoreModule","StorageService","HttpClientModule","StoreModule","ErrorHandlerService","ErrorHandler","notificationService","handleError","ApiModule","static","ngModule","providers","parentModule","Error","registerLocaleData","localeFr","AppModule","addLangs","setDefaultLang","bootstrap","MsalRedirectComponent","MAT_MOMENT_DATE_ADAPTER_OPTIONS","useUtc","loader","TranslateLoader","HttpLoaderFactory","deps","HttpClient","BrowserModule","BrowserAnimationsModule","StoreDevtoolsModule","TranslateHttpLoader","__NgCli_bootstrap_1","bootstrapModule","catch","err","console","setCoordinator","createAction","SET_COORDINATOR","props","getCoordinator","_coordinatorReducer","createReducer","currentCoordinator","initialState","on","data","action","getCoordinatorState","createFeatureSelector","createSelector","updateStudentData","UPDATE_STUDENT_DATA","setStudentData","SET_STUDENT_DATA","getStudentData","_studentReducer","currentStudentData","getStudentState","setThesisRole","SET_THESIS_ROLE","setSupervisor","SET_SUPERVISOR","getSupervisor","_supervisorReducer","currentSupervisor","thesisRole","getSupervisorState","ThesisTimelineActions","getThesisTimeline","updateThesisTimeline","UPDATE_THESIS_TIMELINE","_thesisTimelineReducer","activeStep","steps","getThesisTimelineState","setThesisSupervisor","SET_THESIS","ThesisActions","getThesisSupervisor","_thesisSupervisorReducer","currentThesisSupervisor","getThesisSupervisorState","updateUser","UPDATE_USER","SET_USER","_userReducer","userData","getUserState","e","webpackContext","module"],"sourceRoot":"webpack:///","sources":["./src/app/core/services/globalStorageService/index.ts","./src/app/core/services/globalStorageService/global-storage.service.ts","./src/app/shared/api/api-configuration.ts","./src/app/shared/api/base-service.ts","./src/app/shared/api/models/enum-step-status.ts","./src/app/shared/api/request-builder.ts","./src/app/shared/api/services/answers.service.ts","./src/app/shared/api/services/campus.service.ts","./src/app/shared/api/services/comments.service.ts","./src/app/shared/api/services/conventions.service.ts","./src/app/shared/api/services/coordinator-comments.service.ts","./src/app/shared/api/services/countries.service.ts","./src/app/shared/api/services/documents.service.ts","./src/app/shared/api/services/examination-answers.service.ts","./src/app/shared/api/services/examination-question-categories.service.ts","./src/app/shared/api/services/examination-questions.service.ts","./src/app/shared/api/services/examinations.service.ts","./src/app/shared/api/services/historics.service.ts","./src/app/shared/api/services/professors.service.ts","./src/app/shared/api/services/projects.service.ts","./src/app/shared/api/services/question-categories.service.ts","./src/app/shared/api/services/questions.service.ts","./src/app/shared/api/services/semesters.service.ts","./src/app/shared/api/services/specialisations.service.ts","./src/app/shared/api/services/step-types.service.ts","./src/app/shared/api/services/steps.service.ts","./src/app/shared/api/services/students.service.ts","./src/app/shared/api/services/supervisions.service.ts","./src/app/shared/api/services/supervisors.service.ts","./src/app/shared/api/services/thesis.service.ts","./src/app/shared/components/button/button.component.html","./src/app/shared/components/button/button.component.ts","./src/app/shared/components/horizontal-loader/horizontal-loader.component.html","./src/app/shared/components/horizontal-loader/horizontal-loader.component.ts","./src/app/shared/decorators/autoUnsubscribe.ts","./src/app/shared/enums/roles.enum.ts","./src/app/shared/enums/specialisation.enum.ts","./src/app/shared/services/notification.service.ts","./src/app/shared/material.module.ts","./src/app/shared/shared.module.ts","./src/app/shared/components/unauthorized/unauthorized.component.ts","./src/app/shared/components/unauthorized/unauthorized.component.html","./src/app/core/services/authenticationService/authentication.service.ts","./src/environments/environment.integration.ts","./src/app/core/services/monitoringService/monitoring.service.ts","./src/app/shared/api/services/users.service.ts","./src/app/core/guards/roles.guard.ts","./src/app/shared/api/services/coordinators.service.ts","./src/app/core/guards/auth.guard.ts","./src/app/app-routing.module.ts","./src/app/shared/api/services/arbitrations.service.ts","./src/app/shared/api/services/import-aurion.service.ts","./src/app/shared/api/services/sectors.service.ts","./src/app/shared/api/services/test-modes.service.ts","./src/app/shared/components/language-switch/language-switch.component.ts","./src/app/shared/components/language-switch/languages-icons.ts","./src/app/shared/components/language-switch/language-switch.component.html","./src/app/shared/components/profile-menu/profile-menu.component.html","./src/app/shared/components/profile-menu/profile-menu.component.ts","./src/app/shared/components/header/header.component.html","./src/app/shared/components/header/header.component.ts","./src/app/app.component.html","./src/app/app.component.ts","./src/app/core/services/authenticationService/msal.interceptor.ts","./src/app/core/services/authenticationService/authentication.module.ts","./src/store/app/app.reducer.ts","./src/app/core/core.module.ts","./src/app/core/services/errorHandlerService/error-handler.service.ts","./src/app/shared/api/api.module.ts","./src/app/app.module.ts","./src/main.ts","./src/store/coordinator/coordinator.actions.ts","./src/store/coordinator/coordinator.reducer.ts","./src/store/student/student.actions.ts","./src/store/student/student.reducer.ts","./src/store/supervisor/supervisor.actions.ts","./src/store/supervisor/supervisor.reducer.ts","./src/store/thesis-timeline/thesis-timeline.actions.ts","./src/store/thesis-timeline/thesis-timeline.reducer.ts","./src/store/thesis/thesis.actions.ts","./src/store/thesis/thesis.reducer.ts","./src/store/user/user.actions.ts","./src/store/user/user.reducer.ts","./node_modules/moment/locale/ sync ^\\.\\/.*$"],"sourcesContent":["import { GlobalStorageService } from './global-storage.service';\n\nexport default GlobalStorageService;\n","import { Injectable } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { StudentState } from 'src/store/student/student.states';\nimport { DocumentResponse } from '@sharedModels/document-response';\nimport { StepResponse } from '@sharedModels/step-response';\nimport { ConventionResponse } from '@sharedModels/convention-response';\nimport { StudentActions } from 'src/store/student/student.actions';\nimport { StudentResponse } from '@sharedModels/student-response';\nimport { ThesisResponse } from '@sharedModels/thesis-response';\n\n@Injectable()\nexport class GlobalStorageService {\n  constructor(private store: Store<StudentState>) {}\n\n  public getGridFilters() {\n    const currentFilters = localStorage.getItem('filters');\n    if (currentFilters) return JSON.parse(currentFilters);\n  }\n\n  public setGridFilters(formValues: any) {\n    localStorage.setItem('filters', JSON.stringify(formValues));\n  }\n\n  public getGridColumns(): string[] {\n    const grid = localStorage.getItem('columns');\n\n    if (grid && grid !== '') {\n      return JSON.parse(grid);\n    }\n    return [];\n  }\n\n  public setGridColums(columns: string[]) {\n    localStorage.setItem('columns', JSON.stringify(columns));\n  }\n\n  public setToken(token: string) {\n    localStorage.setItem('token', token);\n  }\n\n  public getToken(): string | null {\n    return localStorage.getItem('token');\n  }\n\n  public setUser(user: StudentResponse) {\n    localStorage.setItem('user', JSON.stringify(user));\n  }\n\n  public getUser(): StudentResponse | null {\n    const userStorage = localStorage.getItem('user');\n    if (userStorage != null) {\n      return JSON.parse(userStorage) as StudentResponse;\n    }\n    return null;\n  }\n\n  public updateStudentCurrentStepAndDispatchToStore(student: StudentResponse, step: StepResponse) {\n    const updates: Partial<StudentResponse> = {\n      ...student,\n      currentStep: step.stepNumber,\n      currentStepId: step.id,\n      currentStepStatus: step.status,\n    };\n    this.store.dispatch(StudentActions.updateStudentData({ updates }));\n  }\n\n  public updateThesisDocumentsAndDispatchToStore(currentStudent: StudentResponse, updatedDocuments: DocumentResponse[]) {\n    const updates: Partial<StudentResponse> = {\n      ...currentStudent,\n      thesis: {\n        ...currentStudent.thesis!,\n        documents: updatedDocuments,\n      },\n    };\n    this.store.dispatch(StudentActions.updateStudentData({ updates }));\n  }\n\n  public updateConventionAndDispatchToStore(currentStudent: StudentResponse, convention: ConventionResponse | undefined) {\n    const updates: Partial<StudentResponse> = {\n      ...currentStudent,\n      thesis: {\n        ...currentStudent.thesis!,\n        convention: convention,\n      },\n    };\n    this.store.dispatch(StudentActions.updateStudentData({ updates }));\n  }\n\n  public updateThesisAndDispatchToStore(currentStudent: StudentResponse, thesis: ThesisResponse | undefined) {\n    const updates: Partial<StudentResponse> = {\n      ...currentStudent,\n      thesis: {\n        ...thesis!,\n      },\n    };\n    this.store.dispatch(StudentActions.updateStudentData({ updates }));\n  }\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\n\n/**\n * Global configuration\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ApiConfiguration {\n  rootUrl: string = '';\n}\n\n/**\n * Parameters for `ApiModule.forRoot()`\n */\nexport interface ApiConfigurationParams {\n  rootUrl?: string;\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { ApiConfiguration } from './api-configuration';\n\n/**\n * Base class for services\n */\n@Injectable()\nexport class BaseService {\n  constructor(\n    protected config: ApiConfiguration,\n    protected http: HttpClient\n  ) {\n  }\n\n  private _rootUrl: string = '';\n\n  /**\n   * Returns the root url for all operations in this service. If not set directly in this\n   * service, will fallback to `ApiConfiguration.rootUrl`.\n   */\n  get rootUrl(): string {\n    return this._rootUrl || this.config.rootUrl;\n  }\n\n  /**\n   * Sets the root URL for API operations in this service.\n   */\n  set rootUrl(rootUrl: string) {\n    this._rootUrl = rootUrl;\n  }\n}\n","/* tslint:disable */\n/* eslint-disable */\nexport enum EnumStepStatus {\n  InProgress = 'InProgress',\n  ValidationInProgress = 'ValidationInProgress',\n  Refused = 'Refused',\n  Validated = 'Validated',\n  Waiting = 'Waiting',\n  ArbitrationInProgress = 'ArbitrationInProgress'\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { HttpRequest, HttpParameterCodec, HttpParams, HttpHeaders, HttpContext } from '@angular/common/http';\n\n/**\n * Custom parameter codec to correctly handle the plus sign in parameter\n * values. See https://github.com/angular/angular/issues/18261\n */\nclass ParameterCodec implements HttpParameterCodec {\n  encodeKey(key: string): string {\n    return encodeURIComponent(key);\n  }\n\n  encodeValue(value: string): string {\n    return encodeURIComponent(value);\n  }\n\n  decodeKey(key: string): string {\n    return decodeURIComponent(key);\n  }\n\n  decodeValue(value: string): string {\n    return decodeURIComponent(value);\n  }\n}\nconst ParameterCodecInstance = new ParameterCodec();\n\n/**\n * Defines the options for appending a parameter\n */\ninterface ParameterOptions {\n  style?: string;\n  explode?: boolean;\n}\n\n/**\n * Base class for a parameter\n */\nabstract class Parameter {\n  constructor(public name: string, public value: any, public options: ParameterOptions, defaultStyle: string, defaultExplode: boolean) {\n    this.options = options || {};\n    if (this.options.style === null || this.options.style === undefined) {\n      this.options.style = defaultStyle;\n    }\n    if (this.options.explode === null || this.options.explode === undefined) {\n      this.options.explode = defaultExplode;\n    }\n  }\n\n  serializeValue(value: any, separator = ','): string {\n    if (value === null || value === undefined) {\n      return '';\n    } else if (value instanceof Array) {\n      return value.map(v => this.serializeValue(v).split(separator).join(encodeURIComponent(separator))).join(separator);\n    } else if (typeof value === 'object') {\n      const array: string[] = [];\n      for (const key of Object.keys(value)) {\n        let propVal = value[key];\n        if (propVal !== null && propVal !== undefined) {\n          propVal = this.serializeValue(propVal).split(separator).join(encodeURIComponent(separator));\n          if (this.options.explode) {\n            array.push(`${key}=${propVal}`);\n          } else {\n            array.push(key);\n            array.push(propVal);\n          }\n        }\n      }\n      return array.join(separator);\n    } else {\n      return String(value);\n    }\n  }\n}\n\n/**\n * A parameter in the operation path\n */\nclass PathParameter extends Parameter {\n  constructor(name: string, value: any, options: ParameterOptions) {\n    super(name, value, options, 'simple', false);\n  }\n\n  append(path: string): string {\n    let value = this.value;\n    if (value === null || value === undefined) {\n      value = '';\n    }\n    let prefix = this.options.style === 'label' ? '.' : '';\n    let separator = this.options.explode ? prefix === '' ? ',' : prefix : ',';\n    let alreadySerialized = false;\n    if (this.options.style === 'matrix') {\n      // The parameter name is just used as prefix, except in some cases...\n      prefix = `;${this.name}=`;\n      if (this.options.explode && typeof value === 'object') {\n        prefix = ';';\n        if (value instanceof Array) {\n          // For arrays we have to repeat the name for each element\n          value = value.map(v => `${this.name}=${this.serializeValue(v, ';')}`);\n          value = value.join(';');\n          alreadySerialized = true;\n        } else {\n          // For objects we have to put each the key / value pairs\n          value = this.serializeValue(value, ';');\n          alreadySerialized = true\n        }\n      }\n    }\n    value = prefix + (alreadySerialized ? value : this.serializeValue(value, separator));\n    // Replace both the plain variable and the corresponding variant taking in the prefix and explode into account\n    path = path.replace(`{${this.name}}`, value);\n    path = path.replace(`{${prefix}${this.name}${this.options.explode ? '*' : ''}}`, value);\n    return path;\n  }\n\n  // @ts-ignore\n  serializeValue(value: any, separator = ','): string {\n    var result = typeof value === 'string' ? encodeURIComponent(value) : super.serializeValue(value, separator);\n    result = result.replace(/%3D/g, '=');\n    result = result.replace(/%3B/g, ';');\n    result = result.replace(/%2C/g, ',');\n    return result;\n  }\n}\n\n/**\n * A parameter in the query\n */\nclass QueryParameter extends Parameter {\n  constructor(name: string, value: any, options: ParameterOptions) {\n    super(name, value, options, 'form', true);\n  }\n\n  append(params: HttpParams): HttpParams {\n    if (this.value instanceof Array) {\n      // Array serialization\n      if (this.options.explode) {\n        for (const v of this.value) {\n          params = params.append(this.name, this.serializeValue(v));\n        }\n      } else {\n        const separator = this.options.style === 'spaceDelimited'\n          ? ' ' : this.options.style === 'pipeDelimited'\n            ? '|' : ',';\n        return params.append(this.name, this.serializeValue(this.value, separator));\n      }\n    } else if (this.value !== null && typeof this.value === 'object') {\n      // Object serialization\n      if (this.options.style === 'deepObject') {\n        // Append a parameter for each key, in the form `name[key]`\n        for (const key of Object.keys(this.value)) {\n          const propVal = this.value[key];\n          if (propVal !== null && propVal !== undefined) {\n            params = params.append(`${this.name}[${key}]`, this.serializeValue(propVal));\n          }\n        }\n      } else if (this.options.explode) {\n        // Append a parameter for each key without using the parameter name\n        for (const key of Object.keys(this.value)) {\n          const propVal = this.value[key];\n          if (propVal !== null && propVal !== undefined) {\n            params = params.append(key, this.serializeValue(propVal));\n          }\n        }\n      } else {\n        // Append a single parameter whose values are a comma-separated list of key,value,key,value...\n        const array: any[] = [];\n        for (const key of Object.keys(this.value)) {\n          const propVal = this.value[key];\n          if (propVal !== null && propVal !== undefined) {\n            array.push(key);\n            array.push(propVal);\n          }\n        }\n        params = params.append(this.name, this.serializeValue(array));\n      }\n    } else if (this.value !== null && this.value !== undefined) {\n      // Plain value\n      params = params.append(this.name, this.serializeValue(this.value));\n    }\n    return params;\n  }\n}\n\n/**\n * A parameter in the HTTP request header\n */\nclass HeaderParameter extends Parameter {\n  constructor(name: string, value: any, options: ParameterOptions) {\n    super(name, value, options, 'simple', false);\n  }\n\n  append(headers: HttpHeaders): HttpHeaders {\n    if (this.value !== null && this.value !== undefined) {\n      if (this.value instanceof Array) {\n        for (const v of this.value) {\n          headers = headers.append(this.name, this.serializeValue(v));\n        }\n      } else {\n        headers = headers.append(this.name, this.serializeValue(this.value));\n      }\n    }\n    return headers;\n  }\n}\n\n/**\n * Helper to build http requests from parameters\n */\nexport class RequestBuilder {\n\n  private _path = new Map<string, PathParameter>();\n  private _query = new Map<string, QueryParameter>();\n  private _header = new Map<string, HeaderParameter>();\n  _bodyContent: any | null;\n  _bodyContentType?: string;\n\n  constructor(\n    public rootUrl: string,\n    public operationPath: string,\n    public method: string) {\n  }\n\n  /**\n   * Sets a path parameter\n   */\n  path(name: string, value: any, options?: ParameterOptions): void {\n    this._path.set(name, new PathParameter(name, value, options || {}));\n  }\n\n  /**\n   * Sets a query parameter\n   */\n  query(name: string, value: any, options?: ParameterOptions): void {\n    this._query.set(name, new QueryParameter(name, value, options || {}));\n  }\n\n  /**\n   * Sets a header parameter\n   */\n  header(name: string, value: any, options?: ParameterOptions): void {\n    this._header.set(name, new HeaderParameter(name, value, options || {}));\n  }\n\n  /**\n   * Sets the body content, along with the content type\n   */\n  body(value: any, contentType = 'application/json'): void {\n    if (value instanceof Blob) {\n      this._bodyContentType = value.type;\n    } else {\n      this._bodyContentType = contentType;\n    }\n    if (this._bodyContentType === 'application/x-www-form-urlencoded' && value !== null && typeof value === 'object') {\n      // Handle URL-encoded data\n      const pairs: Array<[string, string]> = [];\n      for (const key of Object.keys(value)) {\n        let val = value[key];\n        if (!(val instanceof Array)) {\n          val = [val];\n        }\n        for (const v of val) {\n          const formValue = this.formDataValue(v);\n          if (formValue !== null) {\n            pairs.push([key, formValue]);\n          }\n        }\n      }\n      this._bodyContent = pairs.map(p => `${encodeURIComponent(p[0])}=${encodeURIComponent(p[1])}`).join('&');\n    } else if (this._bodyContentType === 'multipart/form-data') {\n      // Handle multipart form data\n      const formData = new FormData();\n      if (value !== null && value !== undefined) {\n        for (const key of Object.keys(value)) {\n          const val = value[key];\n          if (val instanceof Array) {\n            for (const v of val) {\n              const toAppend = this.formDataValue(v);\n              if (toAppend !== null) {\n                formData.append(key, toAppend);\n              }\n            }\n          } else {\n            const toAppend = this.formDataValue(val);\n            if (toAppend !== null) {\n              formData.set(key, toAppend);\n            }\n          }\n        }\n      }\n      this._bodyContent = formData;\n    } else {\n      // The body is the plain content\n      this._bodyContent = value;\n    }\n  }\n\n  private formDataValue(value: any): any {\n    if (value === null || value === undefined) {\n      return null;\n    }\n    if (value instanceof Blob) {\n      return value;\n    }\n    if (typeof value === 'object') {\n      return JSON.stringify(value);\n    }\n    return String(value);\n  }\n\n  /**\n   * Builds the request with the current set parameters\n   */\n  build<T = any>(options?: {\n    /** Which content types to accept */\n    accept?: string;\n\n    /** The expected response type */\n    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';\n\n    /** Whether to report progress on uploads / downloads */\n    reportProgress?: boolean;\n\n    /** Allow passing HttpContext for HttpClient */\n    context?: HttpContext;\n  }): HttpRequest<T> {\n\n    options = options || {};\n\n    // Path parameters\n    let path = this.operationPath;\n    for (const pathParam of this._path.values()) {\n      path = pathParam.append(path);\n    }\n    const url = this.rootUrl + path;\n\n    // Query parameters\n    let httpParams = new HttpParams({\n      encoder: ParameterCodecInstance\n    });\n    for (const queryParam of this._query.values()) {\n      httpParams = queryParam.append(httpParams);\n    }\n\n    // Header parameters\n    let httpHeaders = new HttpHeaders();\n    if (options.accept) {\n      httpHeaders = httpHeaders.append('Accept', options.accept);\n    }\n    for (const headerParam of this._header.values()) {\n      httpHeaders = headerParam.append(httpHeaders);\n    }\n\n    // Request content headers\n    if (this._bodyContentType && !(this._bodyContent instanceof FormData)) {\n      httpHeaders = httpHeaders.set('Content-Type', this._bodyContentType);\n    }\n\n    // Perform the request\n    return new HttpRequest<T>(this.method.toUpperCase(), url, this._bodyContent, {\n      params: httpParams,\n      headers: httpHeaders,\n      responseType: options.responseType,\n      reportProgress: options.reportProgress,\n      context: options.context\n    });\n  }\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { AnswerResponse } from '../models/answer-response';\nimport { CreateOrUpdateAnswerRequest } from '../models/create-or-update-answer-request';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AnswersService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation createAnswerAsync\n   */\n  static readonly CreateAnswerAsyncPath = '/Answers';\n\n  /**\n   * Create answer.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createAnswerAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createAnswerAsync$Plain$Response(params?: {\n    body?: CreateOrUpdateAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<AnswerResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, AnswersService.CreateAnswerAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<AnswerResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create answer.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createAnswerAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createAnswerAsync$Plain(params?: {\n    body?: CreateOrUpdateAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<AnswerResponse> {\n\n    return this.createAnswerAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<AnswerResponse>) => r.body as AnswerResponse)\n    );\n  }\n\n  /**\n   * Create answer.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createAnswerAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createAnswerAsync$Response(params?: {\n    body?: CreateOrUpdateAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<AnswerResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, AnswersService.CreateAnswerAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<AnswerResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create answer.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createAnswerAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createAnswerAsync(params?: {\n    body?: CreateOrUpdateAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<AnswerResponse> {\n\n    return this.createAnswerAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<AnswerResponse>) => r.body as AnswerResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateAnswerAsync\n   */\n  static readonly UpdateAnswerAsyncPath = '/Answers/{answerId}';\n\n  /**\n   * Update answer.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateAnswerAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateAnswerAsync$Plain$Response(params: {\n    answerId: string;\n    body?: CreateOrUpdateAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<AnswerResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, AnswersService.UpdateAnswerAsyncPath, 'put');\n    if (params) {\n      rb.path('answerId', params.answerId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<AnswerResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update answer.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateAnswerAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateAnswerAsync$Plain(params: {\n    answerId: string;\n    body?: CreateOrUpdateAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<AnswerResponse> {\n\n    return this.updateAnswerAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<AnswerResponse>) => r.body as AnswerResponse)\n    );\n  }\n\n  /**\n   * Update answer.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateAnswerAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateAnswerAsync$Response(params: {\n    answerId: string;\n    body?: CreateOrUpdateAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<AnswerResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, AnswersService.UpdateAnswerAsyncPath, 'put');\n    if (params) {\n      rb.path('answerId', params.answerId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<AnswerResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update answer.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateAnswerAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateAnswerAsync(params: {\n    answerId: string;\n    body?: CreateOrUpdateAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<AnswerResponse> {\n\n    return this.updateAnswerAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<AnswerResponse>) => r.body as AnswerResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CampusResponse } from '../models/campus-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CampusService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getAllCampusAsync\n   */\n  static readonly GetAllCampusAsyncPath = '/Campus';\n\n  /**\n   * Get all campus.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllCampusAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllCampusAsync$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<CampusResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CampusService.GetAllCampusAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<CampusResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all campus.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllCampusAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllCampusAsync$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<CampusResponse>> {\n\n    return this.getAllCampusAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<CampusResponse>>) => r.body as Array<CampusResponse>)\n    );\n  }\n\n  /**\n   * Get all campus.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllCampusAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllCampusAsync$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<CampusResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CampusService.GetAllCampusAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<CampusResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all campus.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllCampusAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllCampusAsync(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<CampusResponse>> {\n\n    return this.getAllCampusAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<CampusResponse>>) => r.body as Array<CampusResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CommentRequest } from '../models/comment-request';\nimport { CommentResponse } from '../models/comment-response';\nimport { UpdateCommentCoordinatorRequest } from '../models/update-comment-coordinator-request';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CommentsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation updateCommentByIdAsync\n   */\n  static readonly UpdateCommentByIdAsyncPath = '/Comments';\n\n  /**\n   * Update comment by id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateCommentByIdAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateCommentByIdAsync$Plain$Response(params?: {\n    commentId?: string;\n    body?: UpdateCommentCoordinatorRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<CommentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CommentsService.UpdateCommentByIdAsyncPath, 'put');\n    if (params) {\n      rb.query('commentId', params.commentId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<CommentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update comment by id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateCommentByIdAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateCommentByIdAsync$Plain(params?: {\n    commentId?: string;\n    body?: UpdateCommentCoordinatorRequest\n  },\n  context?: HttpContext\n\n): Observable<CommentResponse> {\n\n    return this.updateCommentByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<CommentResponse>) => r.body as CommentResponse)\n    );\n  }\n\n  /**\n   * Update comment by id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateCommentByIdAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateCommentByIdAsync$Response(params?: {\n    commentId?: string;\n    body?: UpdateCommentCoordinatorRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<CommentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CommentsService.UpdateCommentByIdAsyncPath, 'put');\n    if (params) {\n      rb.query('commentId', params.commentId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<CommentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update comment by id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateCommentByIdAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateCommentByIdAsync(params?: {\n    commentId?: string;\n    body?: UpdateCommentCoordinatorRequest\n  },\n  context?: HttpContext\n\n): Observable<CommentResponse> {\n\n    return this.updateCommentByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<CommentResponse>) => r.body as CommentResponse)\n    );\n  }\n\n  /**\n   * Path part for operation commentsPost\n   */\n  static readonly CommentsPostPath = '/Comments';\n\n  /**\n   * Get all comments by thesisId, stepNumber and commentType.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `commentsPost$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  commentsPost$Plain$Response(params?: {\n    body?: CommentRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<CommentResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CommentsService.CommentsPostPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<CommentResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all comments by thesisId, stepNumber and commentType.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `commentsPost$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  commentsPost$Plain(params?: {\n    body?: CommentRequest\n  },\n  context?: HttpContext\n\n): Observable<Array<CommentResponse>> {\n\n    return this.commentsPost$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<CommentResponse>>) => r.body as Array<CommentResponse>)\n    );\n  }\n\n  /**\n   * Get all comments by thesisId, stepNumber and commentType.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `commentsPost()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  commentsPost$Response(params?: {\n    body?: CommentRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<CommentResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CommentsService.CommentsPostPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<CommentResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all comments by thesisId, stepNumber and commentType.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `commentsPost$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  commentsPost(params?: {\n    body?: CommentRequest\n  },\n  context?: HttpContext\n\n): Observable<Array<CommentResponse>> {\n\n    return this.commentsPost$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<CommentResponse>>) => r.body as Array<CommentResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { ConventionResponse } from '../models/convention-response';\nimport { CreateOrUpdateConventionRequest } from '../models/create-or-update-convention-request';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConventionsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getConventionByIdAsync\n   */\n  static readonly GetConventionByIdAsyncPath = '/Conventions';\n\n  /**\n   * Get convention by conventionId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getConventionByIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getConventionByIdAsync$Plain$Response(params?: {\n    conventionId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ConventionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ConventionsService.GetConventionByIdAsyncPath, 'get');\n    if (params) {\n      rb.query('conventionId', params.conventionId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ConventionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get convention by conventionId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getConventionByIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getConventionByIdAsync$Plain(params?: {\n    conventionId?: string;\n  },\n  context?: HttpContext\n\n): Observable<ConventionResponse> {\n\n    return this.getConventionByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ConventionResponse>) => r.body as ConventionResponse)\n    );\n  }\n\n  /**\n   * Get convention by conventionId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getConventionByIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getConventionByIdAsync$Response(params?: {\n    conventionId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ConventionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ConventionsService.GetConventionByIdAsyncPath, 'get');\n    if (params) {\n      rb.query('conventionId', params.conventionId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ConventionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get convention by conventionId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getConventionByIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getConventionByIdAsync(params?: {\n    conventionId?: string;\n  },\n  context?: HttpContext\n\n): Observable<ConventionResponse> {\n\n    return this.getConventionByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ConventionResponse>) => r.body as ConventionResponse)\n    );\n  }\n\n  /**\n   * Path part for operation createConventionAsync\n   */\n  static readonly CreateConventionAsyncPath = '/Conventions';\n\n  /**\n   * Create convention.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createConventionAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createConventionAsync$Plain$Response(params?: {\n    body?: CreateOrUpdateConventionRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ConventionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ConventionsService.CreateConventionAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ConventionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create convention.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createConventionAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createConventionAsync$Plain(params?: {\n    body?: CreateOrUpdateConventionRequest\n  },\n  context?: HttpContext\n\n): Observable<ConventionResponse> {\n\n    return this.createConventionAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ConventionResponse>) => r.body as ConventionResponse)\n    );\n  }\n\n  /**\n   * Create convention.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createConventionAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createConventionAsync$Response(params?: {\n    body?: CreateOrUpdateConventionRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ConventionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ConventionsService.CreateConventionAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ConventionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create convention.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createConventionAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createConventionAsync(params?: {\n    body?: CreateOrUpdateConventionRequest\n  },\n  context?: HttpContext\n\n): Observable<ConventionResponse> {\n\n    return this.createConventionAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ConventionResponse>) => r.body as ConventionResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateConventionByIdAsync\n   */\n  static readonly UpdateConventionByIdAsyncPath = '/Conventions/{conventionId}';\n\n  /**\n   * Update convention by Id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateConventionByIdAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateConventionByIdAsync$Plain$Response(params: {\n    conventionId: string;\n    body?: CreateOrUpdateConventionRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ConventionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ConventionsService.UpdateConventionByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('conventionId', params.conventionId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ConventionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update convention by Id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateConventionByIdAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateConventionByIdAsync$Plain(params: {\n    conventionId: string;\n    body?: CreateOrUpdateConventionRequest\n  },\n  context?: HttpContext\n\n): Observable<ConventionResponse> {\n\n    return this.updateConventionByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ConventionResponse>) => r.body as ConventionResponse)\n    );\n  }\n\n  /**\n   * Update convention by Id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateConventionByIdAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateConventionByIdAsync$Response(params: {\n    conventionId: string;\n    body?: CreateOrUpdateConventionRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ConventionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ConventionsService.UpdateConventionByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('conventionId', params.conventionId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ConventionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update convention by Id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateConventionByIdAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateConventionByIdAsync(params: {\n    conventionId: string;\n    body?: CreateOrUpdateConventionRequest\n  },\n  context?: HttpContext\n\n): Observable<ConventionResponse> {\n\n    return this.updateConventionByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ConventionResponse>) => r.body as ConventionResponse)\n    );\n  }\n\n  /**\n   * Path part for operation deleteConventionByIdAsync\n   */\n  static readonly DeleteConventionByIdAsyncPath = '/Conventions/{conventionId}';\n\n  /**\n   * Delete convention by Id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `deleteConventionByIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteConventionByIdAsync$Plain$Response(params: {\n    conventionId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ConventionsService.DeleteConventionByIdAsyncPath, 'delete');\n    if (params) {\n      rb.path('conventionId', params.conventionId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * Delete convention by Id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `deleteConventionByIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteConventionByIdAsync$Plain(params: {\n    conventionId: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.deleteConventionByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n  /**\n   * Delete convention by Id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `deleteConventionByIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteConventionByIdAsync$Response(params: {\n    conventionId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ConventionsService.DeleteConventionByIdAsyncPath, 'delete');\n    if (params) {\n      rb.path('conventionId', params.conventionId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * Delete convention by Id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `deleteConventionByIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteConventionByIdAsync(params: {\n    conventionId: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.deleteConventionByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CoordinatorCommentResponse } from '../models/coordinator-comment-response';\nimport { CreateOrUpdateCoordinatorCommentRequest } from '../models/create-or-update-coordinator-comment-request';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CoordinatorCommentsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation createCoordinatorCommentAsync\n   */\n  static readonly CreateCoordinatorCommentAsyncPath = '/CoordinatorComments';\n\n  /**\n   * Create coordinator comment on thesis.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createCoordinatorCommentAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createCoordinatorCommentAsync$Plain$Response(params?: {\n    body?: CreateOrUpdateCoordinatorCommentRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<CoordinatorCommentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CoordinatorCommentsService.CreateCoordinatorCommentAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<CoordinatorCommentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create coordinator comment on thesis.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createCoordinatorCommentAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createCoordinatorCommentAsync$Plain(params?: {\n    body?: CreateOrUpdateCoordinatorCommentRequest\n  },\n  context?: HttpContext\n\n): Observable<CoordinatorCommentResponse> {\n\n    return this.createCoordinatorCommentAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<CoordinatorCommentResponse>) => r.body as CoordinatorCommentResponse)\n    );\n  }\n\n  /**\n   * Create coordinator comment on thesis.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createCoordinatorCommentAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createCoordinatorCommentAsync$Response(params?: {\n    body?: CreateOrUpdateCoordinatorCommentRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<CoordinatorCommentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CoordinatorCommentsService.CreateCoordinatorCommentAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<CoordinatorCommentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create coordinator comment on thesis.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createCoordinatorCommentAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createCoordinatorCommentAsync(params?: {\n    body?: CreateOrUpdateCoordinatorCommentRequest\n  },\n  context?: HttpContext\n\n): Observable<CoordinatorCommentResponse> {\n\n    return this.createCoordinatorCommentAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<CoordinatorCommentResponse>) => r.body as CoordinatorCommentResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateCoordinatorCommentAsync\n   */\n  static readonly UpdateCoordinatorCommentAsyncPath = '/CoordinatorComments/{coordinatorCommentId}';\n\n  /**\n   * Update a coordinator comment.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateCoordinatorCommentAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateCoordinatorCommentAsync$Plain$Response(params: {\n    coordinatorCommentId: string;\n    body?: CreateOrUpdateCoordinatorCommentRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<CoordinatorCommentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CoordinatorCommentsService.UpdateCoordinatorCommentAsyncPath, 'put');\n    if (params) {\n      rb.path('coordinatorCommentId', params.coordinatorCommentId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<CoordinatorCommentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update a coordinator comment.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateCoordinatorCommentAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateCoordinatorCommentAsync$Plain(params: {\n    coordinatorCommentId: string;\n    body?: CreateOrUpdateCoordinatorCommentRequest\n  },\n  context?: HttpContext\n\n): Observable<CoordinatorCommentResponse> {\n\n    return this.updateCoordinatorCommentAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<CoordinatorCommentResponse>) => r.body as CoordinatorCommentResponse)\n    );\n  }\n\n  /**\n   * Update a coordinator comment.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateCoordinatorCommentAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateCoordinatorCommentAsync$Response(params: {\n    coordinatorCommentId: string;\n    body?: CreateOrUpdateCoordinatorCommentRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<CoordinatorCommentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CoordinatorCommentsService.UpdateCoordinatorCommentAsyncPath, 'put');\n    if (params) {\n      rb.path('coordinatorCommentId', params.coordinatorCommentId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<CoordinatorCommentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update a coordinator comment.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateCoordinatorCommentAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateCoordinatorCommentAsync(params: {\n    coordinatorCommentId: string;\n    body?: CreateOrUpdateCoordinatorCommentRequest\n  },\n  context?: HttpContext\n\n): Observable<CoordinatorCommentResponse> {\n\n    return this.updateCoordinatorCommentAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<CoordinatorCommentResponse>) => r.body as CoordinatorCommentResponse)\n    );\n  }\n\n  /**\n   * Path part for operation getCoordinatorCommentsByThesisIdAsync\n   */\n  static readonly GetCoordinatorCommentsByThesisIdAsyncPath = '/CoordinatorComments/GetCoordinatorCommentsByThesisIdAsync';\n\n  /**\n   * Get all the cordinator comments from a thesis.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getCoordinatorCommentsByThesisIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCoordinatorCommentsByThesisIdAsync$Plain$Response(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<CoordinatorCommentResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CoordinatorCommentsService.GetCoordinatorCommentsByThesisIdAsyncPath, 'get');\n    if (params) {\n      rb.query('thesisId', params.thesisId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<CoordinatorCommentResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all the cordinator comments from a thesis.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getCoordinatorCommentsByThesisIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCoordinatorCommentsByThesisIdAsync$Plain(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<CoordinatorCommentResponse>> {\n\n    return this.getCoordinatorCommentsByThesisIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<CoordinatorCommentResponse>>) => r.body as Array<CoordinatorCommentResponse>)\n    );\n  }\n\n  /**\n   * Get all the cordinator comments from a thesis.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getCoordinatorCommentsByThesisIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCoordinatorCommentsByThesisIdAsync$Response(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<CoordinatorCommentResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CoordinatorCommentsService.GetCoordinatorCommentsByThesisIdAsyncPath, 'get');\n    if (params) {\n      rb.query('thesisId', params.thesisId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<CoordinatorCommentResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all the cordinator comments from a thesis.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getCoordinatorCommentsByThesisIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCoordinatorCommentsByThesisIdAsync(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<CoordinatorCommentResponse>> {\n\n    return this.getCoordinatorCommentsByThesisIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<CoordinatorCommentResponse>>) => r.body as Array<CoordinatorCommentResponse>)\n    );\n  }\n\n  /**\n   * Path part for operation deleteCoordinatorCommentAsync\n   */\n  static readonly DeleteCoordinatorCommentAsyncPath = '/CoordinatorComments/{idComment}';\n\n  /**\n   * Delete a coordinator comment.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `deleteCoordinatorCommentAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteCoordinatorCommentAsync$Plain$Response(params: {\n    idComment: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CoordinatorCommentsService.DeleteCoordinatorCommentAsyncPath, 'delete');\n    if (params) {\n      rb.path('idComment', params.idComment, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * Delete a coordinator comment.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `deleteCoordinatorCommentAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteCoordinatorCommentAsync$Plain(params: {\n    idComment: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.deleteCoordinatorCommentAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n  /**\n   * Delete a coordinator comment.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `deleteCoordinatorCommentAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteCoordinatorCommentAsync$Response(params: {\n    idComment: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CoordinatorCommentsService.DeleteCoordinatorCommentAsyncPath, 'delete');\n    if (params) {\n      rb.path('idComment', params.idComment, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * Delete a coordinator comment.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `deleteCoordinatorCommentAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteCoordinatorCommentAsync(params: {\n    idComment: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.deleteCoordinatorCommentAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CountryResponse } from '../models/country-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CountriesService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getAllCountriesAsync\n   */\n  static readonly GetAllCountriesAsyncPath = '/Countries';\n\n  /**\n   * Get all countries.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllCountriesAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllCountriesAsync$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<CountryResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CountriesService.GetAllCountriesAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<CountryResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all countries.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllCountriesAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllCountriesAsync$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<CountryResponse>> {\n\n    return this.getAllCountriesAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<CountryResponse>>) => r.body as Array<CountryResponse>)\n    );\n  }\n\n  /**\n   * Get all countries.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllCountriesAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllCountriesAsync$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<CountryResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CountriesService.GetAllCountriesAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<CountryResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all countries.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllCountriesAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllCountriesAsync(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<CountryResponse>> {\n\n    return this.getAllCountriesAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<CountryResponse>>) => r.body as Array<CountryResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { DocumentResponse } from '../models/document-response';\nimport { GetDocumentRequest } from '../models/get-document-request';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class DocumentsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation createDocumentAsync\n   */\n  static readonly CreateDocumentAsyncPath = '/Documents';\n\n  /**\n   * Create document attached to thesis.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createDocumentAsync$Plain()` instead.\n   *\n   * This method sends `multipart/form-data` and handles request body of type `multipart/form-data`.\n   */\n  createDocumentAsync$Plain$Response(params?: {\n    body?: {\n'ThesisId': string;\n'DocumentTypeCode': string;\n'SpecialisationName': string;\n'ProjectCode': string;\n'FileToUpload': Blob;\n}\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<DocumentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, DocumentsService.CreateDocumentAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'multipart/form-data');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<DocumentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create document attached to thesis.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createDocumentAsync$Plain$Response()` instead.\n   *\n   * This method sends `multipart/form-data` and handles request body of type `multipart/form-data`.\n   */\n  createDocumentAsync$Plain(params?: {\n    body?: {\n'ThesisId': string;\n'DocumentTypeCode': string;\n'SpecialisationName': string;\n'ProjectCode': string;\n'FileToUpload': Blob;\n}\n  },\n  context?: HttpContext\n\n): Observable<DocumentResponse> {\n\n    return this.createDocumentAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<DocumentResponse>) => r.body as DocumentResponse)\n    );\n  }\n\n  /**\n   * Create document attached to thesis.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createDocumentAsync()` instead.\n   *\n   * This method sends `multipart/form-data` and handles request body of type `multipart/form-data`.\n   */\n  createDocumentAsync$Response(params?: {\n    body?: {\n'ThesisId': string;\n'DocumentTypeCode': string;\n'SpecialisationName': string;\n'ProjectCode': string;\n'FileToUpload': Blob;\n}\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<DocumentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, DocumentsService.CreateDocumentAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'multipart/form-data');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<DocumentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create document attached to thesis.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createDocumentAsync$Response()` instead.\n   *\n   * This method sends `multipart/form-data` and handles request body of type `multipart/form-data`.\n   */\n  createDocumentAsync(params?: {\n    body?: {\n'ThesisId': string;\n'DocumentTypeCode': string;\n'SpecialisationName': string;\n'ProjectCode': string;\n'FileToUpload': Blob;\n}\n  },\n  context?: HttpContext\n\n): Observable<DocumentResponse> {\n\n    return this.createDocumentAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<DocumentResponse>) => r.body as DocumentResponse)\n    );\n  }\n\n  /**\n   * Path part for operation deleteDocumentAsync\n   */\n  static readonly DeleteDocumentAsyncPath = '/Documents/{documentId}';\n\n  /**\n   * Delete document attached to thesis.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `deleteDocumentAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteDocumentAsync$Plain$Response(params: {\n    documentId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, DocumentsService.DeleteDocumentAsyncPath, 'delete');\n    if (params) {\n      rb.path('documentId', params.documentId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * Delete document attached to thesis.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `deleteDocumentAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteDocumentAsync$Plain(params: {\n    documentId: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.deleteDocumentAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n  /**\n   * Delete document attached to thesis.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `deleteDocumentAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteDocumentAsync$Response(params: {\n    documentId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, DocumentsService.DeleteDocumentAsyncPath, 'delete');\n    if (params) {\n      rb.path('documentId', params.documentId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * Delete document attached to thesis.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `deleteDocumentAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteDocumentAsync(params: {\n    documentId: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.deleteDocumentAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n  /**\n   * Path part for operation getDocumentsByThesisAndTypeAsync\n   */\n  static readonly GetDocumentsByThesisAndTypeAsyncPath = '/Documents/GetDocumentsByThesisAndTypeAsync';\n\n  /**\n   * Get documents of the thesis and document type.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getDocumentsByThesisAndTypeAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  getDocumentsByThesisAndTypeAsync$Plain$Response(params?: {\n    body?: GetDocumentRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<DocumentResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, DocumentsService.GetDocumentsByThesisAndTypeAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<DocumentResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get documents of the thesis and document type.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getDocumentsByThesisAndTypeAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  getDocumentsByThesisAndTypeAsync$Plain(params?: {\n    body?: GetDocumentRequest\n  },\n  context?: HttpContext\n\n): Observable<Array<DocumentResponse>> {\n\n    return this.getDocumentsByThesisAndTypeAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<DocumentResponse>>) => r.body as Array<DocumentResponse>)\n    );\n  }\n\n  /**\n   * Get documents of the thesis and document type.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getDocumentsByThesisAndTypeAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  getDocumentsByThesisAndTypeAsync$Response(params?: {\n    body?: GetDocumentRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<DocumentResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, DocumentsService.GetDocumentsByThesisAndTypeAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<DocumentResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get documents of the thesis and document type.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getDocumentsByThesisAndTypeAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  getDocumentsByThesisAndTypeAsync(params?: {\n    body?: GetDocumentRequest\n  },\n  context?: HttpContext\n\n): Observable<Array<DocumentResponse>> {\n\n    return this.getDocumentsByThesisAndTypeAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<DocumentResponse>>) => r.body as Array<DocumentResponse>)\n    );\n  }\n\n  /**\n   * Path part for operation createDocumentByThesisAndTypeAsync\n   */\n  static readonly CreateDocumentByThesisAndTypeAsyncPath = '/Documents/CreateDocumentByThesisAndTypeAsync';\n\n  /**\n   * Create document attached to thesis by specific document type.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createDocumentByThesisAndTypeAsync$Plain()` instead.\n   *\n   * This method sends `multipart/form-data` and handles request body of type `multipart/form-data`.\n   */\n  createDocumentByThesisAndTypeAsync$Plain$Response(params?: {\n    body?: {\n'ThesisId': string;\n'CreatedBy': string;\n'DocumentTypeCode': string;\n'FileToUpload': Blob;\n}\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<DocumentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, DocumentsService.CreateDocumentByThesisAndTypeAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'multipart/form-data');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<DocumentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create document attached to thesis by specific document type.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createDocumentByThesisAndTypeAsync$Plain$Response()` instead.\n   *\n   * This method sends `multipart/form-data` and handles request body of type `multipart/form-data`.\n   */\n  createDocumentByThesisAndTypeAsync$Plain(params?: {\n    body?: {\n'ThesisId': string;\n'CreatedBy': string;\n'DocumentTypeCode': string;\n'FileToUpload': Blob;\n}\n  },\n  context?: HttpContext\n\n): Observable<DocumentResponse> {\n\n    return this.createDocumentByThesisAndTypeAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<DocumentResponse>) => r.body as DocumentResponse)\n    );\n  }\n\n  /**\n   * Create document attached to thesis by specific document type.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createDocumentByThesisAndTypeAsync()` instead.\n   *\n   * This method sends `multipart/form-data` and handles request body of type `multipart/form-data`.\n   */\n  createDocumentByThesisAndTypeAsync$Response(params?: {\n    body?: {\n'ThesisId': string;\n'CreatedBy': string;\n'DocumentTypeCode': string;\n'FileToUpload': Blob;\n}\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<DocumentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, DocumentsService.CreateDocumentByThesisAndTypeAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'multipart/form-data');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<DocumentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create document attached to thesis by specific document type.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createDocumentByThesisAndTypeAsync$Response()` instead.\n   *\n   * This method sends `multipart/form-data` and handles request body of type `multipart/form-data`.\n   */\n  createDocumentByThesisAndTypeAsync(params?: {\n    body?: {\n'ThesisId': string;\n'CreatedBy': string;\n'DocumentTypeCode': string;\n'FileToUpload': Blob;\n}\n  },\n  context?: HttpContext\n\n): Observable<DocumentResponse> {\n\n    return this.createDocumentByThesisAndTypeAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<DocumentResponse>) => r.body as DocumentResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CreateOrUpdateExaminationAnswerRequest } from '../models/create-or-update-examination-answer-request';\nimport { ExaminationAnswerResponse } from '../models/examination-answer-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ExaminationAnswersService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation createExaminationAnswerAsync\n   */\n  static readonly CreateExaminationAnswerAsyncPath = '/ExaminationAnswers';\n\n  /**\n   * Create examination.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createExaminationAnswerAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createExaminationAnswerAsync$Plain$Response(params?: {\n    body?: CreateOrUpdateExaminationAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ExaminationAnswerResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationAnswersService.CreateExaminationAnswerAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ExaminationAnswerResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create examination.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createExaminationAnswerAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createExaminationAnswerAsync$Plain(params?: {\n    body?: CreateOrUpdateExaminationAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<ExaminationAnswerResponse> {\n\n    return this.createExaminationAnswerAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ExaminationAnswerResponse>) => r.body as ExaminationAnswerResponse)\n    );\n  }\n\n  /**\n   * Create examination.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createExaminationAnswerAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createExaminationAnswerAsync$Response(params?: {\n    body?: CreateOrUpdateExaminationAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ExaminationAnswerResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationAnswersService.CreateExaminationAnswerAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ExaminationAnswerResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create examination.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createExaminationAnswerAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createExaminationAnswerAsync(params?: {\n    body?: CreateOrUpdateExaminationAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<ExaminationAnswerResponse> {\n\n    return this.createExaminationAnswerAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ExaminationAnswerResponse>) => r.body as ExaminationAnswerResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateExaminationAnswerByIdAsync\n   */\n  static readonly UpdateExaminationAnswerByIdAsyncPath = '/ExaminationAnswers/{examinationAnswerId}';\n\n  /**\n   * Update examination.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateExaminationAnswerByIdAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationAnswerByIdAsync$Plain$Response(params: {\n    examinationAnswerId: string;\n    body?: CreateOrUpdateExaminationAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ExaminationAnswerResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationAnswersService.UpdateExaminationAnswerByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('examinationAnswerId', params.examinationAnswerId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ExaminationAnswerResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update examination.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateExaminationAnswerByIdAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationAnswerByIdAsync$Plain(params: {\n    examinationAnswerId: string;\n    body?: CreateOrUpdateExaminationAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<ExaminationAnswerResponse> {\n\n    return this.updateExaminationAnswerByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ExaminationAnswerResponse>) => r.body as ExaminationAnswerResponse)\n    );\n  }\n\n  /**\n   * Update examination.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateExaminationAnswerByIdAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationAnswerByIdAsync$Response(params: {\n    examinationAnswerId: string;\n    body?: CreateOrUpdateExaminationAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ExaminationAnswerResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationAnswersService.UpdateExaminationAnswerByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('examinationAnswerId', params.examinationAnswerId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ExaminationAnswerResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update examination.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateExaminationAnswerByIdAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationAnswerByIdAsync(params: {\n    examinationAnswerId: string;\n    body?: CreateOrUpdateExaminationAnswerRequest\n  },\n  context?: HttpContext\n\n): Observable<ExaminationAnswerResponse> {\n\n    return this.updateExaminationAnswerByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ExaminationAnswerResponse>) => r.body as ExaminationAnswerResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { ExaminationQuestionCategoryResponse } from '../models/examination-question-category-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ExaminationQuestionCategoriesService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync\n   */\n  static readonly GetAllExaminationQuestionCategoriesBySpecialisationAndProgramAsyncPath = '/ExaminationQuestionCategories/{specialisationId}/{programCode}';\n\n  /**\n   * Get all examination question categories according to the specialisationId and programId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Plain$Response(params: {\n    specialisationId: string;\n    programCode: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ExaminationQuestionCategoryResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationQuestionCategoriesService.GetAllExaminationQuestionCategoriesBySpecialisationAndProgramAsyncPath, 'get');\n    if (params) {\n      rb.path('specialisationId', params.specialisationId, {});\n      rb.path('programCode', params.programCode, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ExaminationQuestionCategoryResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all examination question categories according to the specialisationId and programId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Plain(params: {\n    specialisationId: string;\n    programCode: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<ExaminationQuestionCategoryResponse>> {\n\n    return this.getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ExaminationQuestionCategoryResponse>>) => r.body as Array<ExaminationQuestionCategoryResponse>)\n    );\n  }\n\n  /**\n   * Get all examination question categories according to the specialisationId and programId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Response(params: {\n    specialisationId: string;\n    programCode: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ExaminationQuestionCategoryResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationQuestionCategoriesService.GetAllExaminationQuestionCategoriesBySpecialisationAndProgramAsyncPath, 'get');\n    if (params) {\n      rb.path('specialisationId', params.specialisationId, {});\n      rb.path('programCode', params.programCode, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ExaminationQuestionCategoryResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all examination question categories according to the specialisationId and programId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync(params: {\n    specialisationId: string;\n    programCode: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<ExaminationQuestionCategoryResponse>> {\n\n    return this.getAllExaminationQuestionCategoriesBySpecialisationAndProgramAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ExaminationQuestionCategoryResponse>>) => r.body as Array<ExaminationQuestionCategoryResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { ExaminationQuestionResponse } from '../models/examination-question-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ExaminationQuestionsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync\n   */\n  static readonly GetAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsyncPath = '/ExaminationQuestions';\n\n  /**\n   * Get all examinations questions + answers linked according to examinationId and examinationQuestionCategoryId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Plain$Response(params?: {\n    examinationId?: string;\n    questionCategoryId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ExaminationQuestionResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationQuestionsService.GetAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsyncPath, 'get');\n    if (params) {\n      rb.query('examinationId', params.examinationId, {});\n      rb.query('questionCategoryId', params.questionCategoryId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ExaminationQuestionResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all examinations questions + answers linked according to examinationId and examinationQuestionCategoryId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Plain(params?: {\n    examinationId?: string;\n    questionCategoryId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<ExaminationQuestionResponse>> {\n\n    return this.getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ExaminationQuestionResponse>>) => r.body as Array<ExaminationQuestionResponse>)\n    );\n  }\n\n  /**\n   * Get all examinations questions + answers linked according to examinationId and examinationQuestionCategoryId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Response(params?: {\n    examinationId?: string;\n    questionCategoryId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ExaminationQuestionResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationQuestionsService.GetAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsyncPath, 'get');\n    if (params) {\n      rb.query('examinationId', params.examinationId, {});\n      rb.query('questionCategoryId', params.questionCategoryId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ExaminationQuestionResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all examinations questions + answers linked according to examinationId and examinationQuestionCategoryId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync(params?: {\n    examinationId?: string;\n    questionCategoryId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<ExaminationQuestionResponse>> {\n\n    return this.getAllExaminationQuestionsAnswersByExaminationAndCategoryIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ExaminationQuestionResponse>>) => r.body as Array<ExaminationQuestionResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CreateOrUpdateExaminationRequest } from '../models/create-or-update-examination-request';\nimport { ExaminationResponse } from '../models/examination-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ExaminationsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation createExaminationAsync\n   */\n  static readonly CreateExaminationAsyncPath = '/Examinations';\n\n  /**\n   * Create examination.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createExaminationAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createExaminationAsync$Plain$Response(params?: {\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ExaminationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationsService.CreateExaminationAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ExaminationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create examination.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createExaminationAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createExaminationAsync$Plain(params?: {\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<ExaminationResponse> {\n\n    return this.createExaminationAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ExaminationResponse>) => r.body as ExaminationResponse)\n    );\n  }\n\n  /**\n   * Create examination.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createExaminationAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createExaminationAsync$Response(params?: {\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ExaminationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationsService.CreateExaminationAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ExaminationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create examination.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createExaminationAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createExaminationAsync(params?: {\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<ExaminationResponse> {\n\n    return this.createExaminationAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ExaminationResponse>) => r.body as ExaminationResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateExaminationByIdAsync\n   */\n  static readonly UpdateExaminationByIdAsyncPath = '/Examinations/{examinationId}';\n\n  /**\n   * Update examination.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateExaminationByIdAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationByIdAsync$Plain$Response(params: {\n    examinationId: string;\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ExaminationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationsService.UpdateExaminationByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('examinationId', params.examinationId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ExaminationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update examination.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateExaminationByIdAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationByIdAsync$Plain(params: {\n    examinationId: string;\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<ExaminationResponse> {\n\n    return this.updateExaminationByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ExaminationResponse>) => r.body as ExaminationResponse)\n    );\n  }\n\n  /**\n   * Update examination.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateExaminationByIdAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationByIdAsync$Response(params: {\n    examinationId: string;\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ExaminationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ExaminationsService.UpdateExaminationByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('examinationId', params.examinationId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ExaminationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update examination.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateExaminationByIdAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationByIdAsync(params: {\n    examinationId: string;\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<ExaminationResponse> {\n\n    return this.updateExaminationByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ExaminationResponse>) => r.body as ExaminationResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { HistoricResponse } from '../models/historic-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class HistoricsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getAllHistoricsByThesisIdAsync\n   */\n  static readonly GetAllHistoricsByThesisIdAsyncPath = '/Historics';\n\n  /**\n   * Get all historics by thesisId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllHistoricsByThesisIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllHistoricsByThesisIdAsync$Plain$Response(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<HistoricResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, HistoricsService.GetAllHistoricsByThesisIdAsyncPath, 'get');\n    if (params) {\n      rb.query('thesisId', params.thesisId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<HistoricResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all historics by thesisId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllHistoricsByThesisIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllHistoricsByThesisIdAsync$Plain(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<HistoricResponse>> {\n\n    return this.getAllHistoricsByThesisIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<HistoricResponse>>) => r.body as Array<HistoricResponse>)\n    );\n  }\n\n  /**\n   * Get all historics by thesisId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllHistoricsByThesisIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllHistoricsByThesisIdAsync$Response(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<HistoricResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, HistoricsService.GetAllHistoricsByThesisIdAsyncPath, 'get');\n    if (params) {\n      rb.query('thesisId', params.thesisId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<HistoricResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all historics by thesisId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllHistoricsByThesisIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllHistoricsByThesisIdAsync(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<HistoricResponse>> {\n\n    return this.getAllHistoricsByThesisIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<HistoricResponse>>) => r.body as Array<HistoricResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { ProfessorSearchResponse } from '../models/professor-search-response';\nimport { ProfessorThesisInformationsResponse } from '../models/professor-thesis-informations-response';\nimport { SupervisorResponse } from '../models/supervisor-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProfessorsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getProfessorConnectedAsync\n   */\n  static readonly GetProfessorConnectedAsyncPath = '/Professors';\n\n  /**\n   * Get professor connected.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getProfessorConnectedAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorConnectedAsync$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SupervisorResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProfessorsService.GetProfessorConnectedAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SupervisorResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get professor connected.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getProfessorConnectedAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorConnectedAsync$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<SupervisorResponse> {\n\n    return this.getProfessorConnectedAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SupervisorResponse>) => r.body as SupervisorResponse)\n    );\n  }\n\n  /**\n   * Get professor connected.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getProfessorConnectedAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorConnectedAsync$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SupervisorResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProfessorsService.GetProfessorConnectedAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SupervisorResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get professor connected.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getProfessorConnectedAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorConnectedAsync(params?: {\n  },\n  context?: HttpContext\n\n): Observable<SupervisorResponse> {\n\n    return this.getProfessorConnectedAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SupervisorResponse>) => r.body as SupervisorResponse)\n    );\n  }\n\n  /**\n   * Path part for operation getProfessorsBySectorIdAsync\n   */\n  static readonly GetProfessorsBySectorIdAsyncPath = '/Professors/search/sector/{sectorId}';\n\n  /**\n   * Get all professors according to the sectorId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getProfessorsBySectorIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorsBySectorIdAsync$Plain$Response(params: {\n    sectorId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ProfessorSearchResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProfessorsService.GetProfessorsBySectorIdAsyncPath, 'get');\n    if (params) {\n      rb.path('sectorId', params.sectorId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ProfessorSearchResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all professors according to the sectorId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getProfessorsBySectorIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorsBySectorIdAsync$Plain(params: {\n    sectorId: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<ProfessorSearchResponse>> {\n\n    return this.getProfessorsBySectorIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ProfessorSearchResponse>>) => r.body as Array<ProfessorSearchResponse>)\n    );\n  }\n\n  /**\n   * Get all professors according to the sectorId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getProfessorsBySectorIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorsBySectorIdAsync$Response(params: {\n    sectorId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ProfessorSearchResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProfessorsService.GetProfessorsBySectorIdAsyncPath, 'get');\n    if (params) {\n      rb.path('sectorId', params.sectorId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ProfessorSearchResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all professors according to the sectorId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getProfessorsBySectorIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorsBySectorIdAsync(params: {\n    sectorId: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<ProfessorSearchResponse>> {\n\n    return this.getProfessorsBySectorIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ProfessorSearchResponse>>) => r.body as Array<ProfessorSearchResponse>)\n    );\n  }\n\n  /**\n   * Path part for operation getSupervisorsByLastNameAsync\n   */\n  static readonly GetSupervisorsByLastNameAsyncPath = '/Professors/search/supervisors/{lastName}';\n\n  /**\n   * Get all supervisors (professors with state IsSupervisor = true) with LastName match (used with front autocomplete).\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getSupervisorsByLastNameAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSupervisorsByLastNameAsync$Plain$Response(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<SupervisorResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProfessorsService.GetSupervisorsByLastNameAsyncPath, 'get');\n    if (params) {\n      rb.path('lastName', params.lastName, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<SupervisorResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all supervisors (professors with state IsSupervisor = true) with LastName match (used with front autocomplete).\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getSupervisorsByLastNameAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSupervisorsByLastNameAsync$Plain(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<SupervisorResponse>> {\n\n    return this.getSupervisorsByLastNameAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<SupervisorResponse>>) => r.body as Array<SupervisorResponse>)\n    );\n  }\n\n  /**\n   * Get all supervisors (professors with state IsSupervisor = true) with LastName match (used with front autocomplete).\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getSupervisorsByLastNameAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSupervisorsByLastNameAsync$Response(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<SupervisorResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProfessorsService.GetSupervisorsByLastNameAsyncPath, 'get');\n    if (params) {\n      rb.path('lastName', params.lastName, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<SupervisorResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all supervisors (professors with state IsSupervisor = true) with LastName match (used with front autocomplete).\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getSupervisorsByLastNameAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSupervisorsByLastNameAsync(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<SupervisorResponse>> {\n\n    return this.getSupervisorsByLastNameAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<SupervisorResponse>>) => r.body as Array<SupervisorResponse>)\n    );\n  }\n\n  /**\n   * Path part for operation getSupervisorsAndCoSupervisorsByLastNameAsync\n   */\n  static readonly GetSupervisorsAndCoSupervisorsByLastNameAsyncPath = '/Professors/search/supervisorsancosupervisors/{lastName}';\n\n  /**\n   * Get all supervisors (professors with state IsSupervisor = true) and cosupervisors (IsCoSupervisor = true)\n   * with LastName match (used with front autocomplete).\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getSupervisorsAndCoSupervisorsByLastNameAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSupervisorsAndCoSupervisorsByLastNameAsync$Plain$Response(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<SupervisorResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProfessorsService.GetSupervisorsAndCoSupervisorsByLastNameAsyncPath, 'get');\n    if (params) {\n      rb.path('lastName', params.lastName, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<SupervisorResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all supervisors (professors with state IsSupervisor = true) and cosupervisors (IsCoSupervisor = true)\n   * with LastName match (used with front autocomplete).\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getSupervisorsAndCoSupervisorsByLastNameAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSupervisorsAndCoSupervisorsByLastNameAsync$Plain(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<SupervisorResponse>> {\n\n    return this.getSupervisorsAndCoSupervisorsByLastNameAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<SupervisorResponse>>) => r.body as Array<SupervisorResponse>)\n    );\n  }\n\n  /**\n   * Get all supervisors (professors with state IsSupervisor = true) and cosupervisors (IsCoSupervisor = true)\n   * with LastName match (used with front autocomplete).\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getSupervisorsAndCoSupervisorsByLastNameAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSupervisorsAndCoSupervisorsByLastNameAsync$Response(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<SupervisorResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProfessorsService.GetSupervisorsAndCoSupervisorsByLastNameAsyncPath, 'get');\n    if (params) {\n      rb.path('lastName', params.lastName, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<SupervisorResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all supervisors (professors with state IsSupervisor = true) and cosupervisors (IsCoSupervisor = true)\n   * with LastName match (used with front autocomplete).\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getSupervisorsAndCoSupervisorsByLastNameAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSupervisorsAndCoSupervisorsByLastNameAsync(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<SupervisorResponse>> {\n\n    return this.getSupervisorsAndCoSupervisorsByLastNameAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<SupervisorResponse>>) => r.body as Array<SupervisorResponse>)\n    );\n  }\n\n  /**\n   * Path part for operation getProfessorInformationsByIdAsync\n   */\n  static readonly GetProfessorInformationsByIdAsyncPath = '/Professors/informations/{professorId}';\n\n  /**\n   * Return informations about a professor for the coordinator view.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getProfessorInformationsByIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorInformationsByIdAsync$Plain$Response(params: {\n    professorId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ProfessorThesisInformationsResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProfessorsService.GetProfessorInformationsByIdAsyncPath, 'get');\n    if (params) {\n      rb.path('professorId', params.professorId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ProfessorThesisInformationsResponse>;\n      })\n    );\n  }\n\n  /**\n   * Return informations about a professor for the coordinator view.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getProfessorInformationsByIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorInformationsByIdAsync$Plain(params: {\n    professorId: string;\n  },\n  context?: HttpContext\n\n): Observable<ProfessorThesisInformationsResponse> {\n\n    return this.getProfessorInformationsByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ProfessorThesisInformationsResponse>) => r.body as ProfessorThesisInformationsResponse)\n    );\n  }\n\n  /**\n   * Return informations about a professor for the coordinator view.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getProfessorInformationsByIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorInformationsByIdAsync$Response(params: {\n    professorId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ProfessorThesisInformationsResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProfessorsService.GetProfessorInformationsByIdAsyncPath, 'get');\n    if (params) {\n      rb.path('professorId', params.professorId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ProfessorThesisInformationsResponse>;\n      })\n    );\n  }\n\n  /**\n   * Return informations about a professor for the coordinator view.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getProfessorInformationsByIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getProfessorInformationsByIdAsync(params: {\n    professorId: string;\n  },\n  context?: HttpContext\n\n): Observable<ProfessorThesisInformationsResponse> {\n\n    return this.getProfessorInformationsByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ProfessorThesisInformationsResponse>) => r.body as ProfessorThesisInformationsResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { ProjectResponse } from '../models/project-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProjectsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getAllProjectsAsync\n   */\n  static readonly GetAllProjectsAsyncPath = '/Projects';\n\n  /**\n   * Get all projects (mémoire, pce, pci, etc...).\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllProjectsAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllProjectsAsync$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ProjectResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProjectsService.GetAllProjectsAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ProjectResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all projects (mémoire, pce, pci, etc...).\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllProjectsAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllProjectsAsync$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<ProjectResponse>> {\n\n    return this.getAllProjectsAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ProjectResponse>>) => r.body as Array<ProjectResponse>)\n    );\n  }\n\n  /**\n   * Get all projects (mémoire, pce, pci, etc...).\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllProjectsAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllProjectsAsync$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ProjectResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ProjectsService.GetAllProjectsAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ProjectResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all projects (mémoire, pce, pci, etc...).\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllProjectsAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllProjectsAsync(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<ProjectResponse>> {\n\n    return this.getAllProjectsAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ProjectResponse>>) => r.body as Array<ProjectResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { QuestionCategoryTabResponse } from '../models/question-category-tab-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class QuestionCategoriesService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getQuestionCategoriesByStudentIdAsync\n   */\n  static readonly GetQuestionCategoriesByStudentIdAsyncPath = '/QuestionCategories/{studentId}';\n\n  /**\n   * Get all question categories + computation current category of student for the front.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getQuestionCategoriesByStudentIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getQuestionCategoriesByStudentIdAsync$Plain$Response(params: {\n    studentId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<QuestionCategoryTabResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, QuestionCategoriesService.GetQuestionCategoriesByStudentIdAsyncPath, 'get');\n    if (params) {\n      rb.path('studentId', params.studentId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<QuestionCategoryTabResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all question categories + computation current category of student for the front.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getQuestionCategoriesByStudentIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getQuestionCategoriesByStudentIdAsync$Plain(params: {\n    studentId: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<QuestionCategoryTabResponse>> {\n\n    return this.getQuestionCategoriesByStudentIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<QuestionCategoryTabResponse>>) => r.body as Array<QuestionCategoryTabResponse>)\n    );\n  }\n\n  /**\n   * Get all question categories + computation current category of student for the front.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getQuestionCategoriesByStudentIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getQuestionCategoriesByStudentIdAsync$Response(params: {\n    studentId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<QuestionCategoryTabResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, QuestionCategoriesService.GetQuestionCategoriesByStudentIdAsyncPath, 'get');\n    if (params) {\n      rb.path('studentId', params.studentId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<QuestionCategoryTabResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all question categories + computation current category of student for the front.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getQuestionCategoriesByStudentIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getQuestionCategoriesByStudentIdAsync(params: {\n    studentId: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<QuestionCategoryTabResponse>> {\n\n    return this.getQuestionCategoriesByStudentIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<QuestionCategoryTabResponse>>) => r.body as Array<QuestionCategoryTabResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { QuestionAnswerResponse } from '../models/question-answer-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class QuestionsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getQuestionsAndAnswersByStudentAndCategoryIdAsync\n   */\n  static readonly GetQuestionsAndAnswersByStudentAndCategoryIdAsyncPath = '/Questions';\n\n  /**\n   * Get all questions + answers according to the  studentId and questionCategoryId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getQuestionsAndAnswersByStudentAndCategoryIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getQuestionsAndAnswersByStudentAndCategoryIdAsync$Plain$Response(params?: {\n    studentId?: string;\n    questionCategoryId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<QuestionAnswerResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, QuestionsService.GetQuestionsAndAnswersByStudentAndCategoryIdAsyncPath, 'get');\n    if (params) {\n      rb.query('studentId', params.studentId, {});\n      rb.query('questionCategoryId', params.questionCategoryId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<QuestionAnswerResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all questions + answers according to the  studentId and questionCategoryId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getQuestionsAndAnswersByStudentAndCategoryIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getQuestionsAndAnswersByStudentAndCategoryIdAsync$Plain(params?: {\n    studentId?: string;\n    questionCategoryId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<QuestionAnswerResponse>> {\n\n    return this.getQuestionsAndAnswersByStudentAndCategoryIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<QuestionAnswerResponse>>) => r.body as Array<QuestionAnswerResponse>)\n    );\n  }\n\n  /**\n   * Get all questions + answers according to the  studentId and questionCategoryId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getQuestionsAndAnswersByStudentAndCategoryIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getQuestionsAndAnswersByStudentAndCategoryIdAsync$Response(params?: {\n    studentId?: string;\n    questionCategoryId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<QuestionAnswerResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, QuestionsService.GetQuestionsAndAnswersByStudentAndCategoryIdAsyncPath, 'get');\n    if (params) {\n      rb.query('studentId', params.studentId, {});\n      rb.query('questionCategoryId', params.questionCategoryId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<QuestionAnswerResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all questions + answers according to the  studentId and questionCategoryId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getQuestionsAndAnswersByStudentAndCategoryIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getQuestionsAndAnswersByStudentAndCategoryIdAsync(params?: {\n    studentId?: string;\n    questionCategoryId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<QuestionAnswerResponse>> {\n\n    return this.getQuestionsAndAnswersByStudentAndCategoryIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<QuestionAnswerResponse>>) => r.body as Array<QuestionAnswerResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CreateOrUpdateSemesterRequest } from '../models/create-or-update-semester-request';\nimport { SemesterResponse } from '../models/semester-response';\nimport { SemesterSearchResponse } from '../models/semester-search-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SemestersService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getCurrentSemesterBySpecialisationAndProjectIdAsync\n   */\n  static readonly GetCurrentSemesterBySpecialisationAndProjectIdAsyncPath = '/Semesters/current';\n\n  /**\n   * Get current semester by specialisation and project id\n   * Used by front during register step (classic/alternant) or import aurion.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getCurrentSemesterBySpecialisationAndProjectIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCurrentSemesterBySpecialisationAndProjectIdAsync$Plain$Response(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SemesterResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SemestersService.GetCurrentSemesterBySpecialisationAndProjectIdAsyncPath, 'get');\n    if (params) {\n      rb.query('specialisationId', params.specialisationId, {});\n      rb.query('projectId', params.projectId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SemesterResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get current semester by specialisation and project id\n   * Used by front during register step (classic/alternant) or import aurion.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getCurrentSemesterBySpecialisationAndProjectIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCurrentSemesterBySpecialisationAndProjectIdAsync$Plain(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<SemesterResponse> {\n\n    return this.getCurrentSemesterBySpecialisationAndProjectIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SemesterResponse>) => r.body as SemesterResponse)\n    );\n  }\n\n  /**\n   * Get current semester by specialisation and project id\n   * Used by front during register step (classic/alternant) or import aurion.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getCurrentSemesterBySpecialisationAndProjectIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCurrentSemesterBySpecialisationAndProjectIdAsync$Response(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SemesterResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SemestersService.GetCurrentSemesterBySpecialisationAndProjectIdAsyncPath, 'get');\n    if (params) {\n      rb.query('specialisationId', params.specialisationId, {});\n      rb.query('projectId', params.projectId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SemesterResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get current semester by specialisation and project id\n   * Used by front during register step (classic/alternant) or import aurion.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getCurrentSemesterBySpecialisationAndProjectIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCurrentSemesterBySpecialisationAndProjectIdAsync(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<SemesterResponse> {\n\n    return this.getCurrentSemesterBySpecialisationAndProjectIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SemesterResponse>) => r.body as SemesterResponse)\n    );\n  }\n\n  /**\n   * Path part for operation getSemesterByIdAsync\n   */\n  static readonly GetSemesterByIdAsyncPath = '/Semesters/{semesterId}';\n\n  /**\n   * Get semester by id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getSemesterByIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSemesterByIdAsync$Plain$Response(params: {\n    semesterId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SemesterResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SemestersService.GetSemesterByIdAsyncPath, 'get');\n    if (params) {\n      rb.path('semesterId', params.semesterId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SemesterResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get semester by id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getSemesterByIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSemesterByIdAsync$Plain(params: {\n    semesterId: string;\n  },\n  context?: HttpContext\n\n): Observable<SemesterResponse> {\n\n    return this.getSemesterByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SemesterResponse>) => r.body as SemesterResponse)\n    );\n  }\n\n  /**\n   * Get semester by id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getSemesterByIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSemesterByIdAsync$Response(params: {\n    semesterId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SemesterResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SemestersService.GetSemesterByIdAsyncPath, 'get');\n    if (params) {\n      rb.path('semesterId', params.semesterId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SemesterResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get semester by id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getSemesterByIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getSemesterByIdAsync(params: {\n    semesterId: string;\n  },\n  context?: HttpContext\n\n): Observable<SemesterResponse> {\n\n    return this.getSemesterByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SemesterResponse>) => r.body as SemesterResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateSemesterByIdAsync\n   */\n  static readonly UpdateSemesterByIdAsyncPath = '/Semesters/{semesterId}';\n\n  /**\n   * Update semester and semesterStep by semester id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateSemesterByIdAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateSemesterByIdAsync$Plain$Response(params: {\n    semesterId: string;\n    body?: CreateOrUpdateSemesterRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SemesterResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SemestersService.UpdateSemesterByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('semesterId', params.semesterId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SemesterResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update semester and semesterStep by semester id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateSemesterByIdAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateSemesterByIdAsync$Plain(params: {\n    semesterId: string;\n    body?: CreateOrUpdateSemesterRequest\n  },\n  context?: HttpContext\n\n): Observable<SemesterResponse> {\n\n    return this.updateSemesterByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SemesterResponse>) => r.body as SemesterResponse)\n    );\n  }\n\n  /**\n   * Update semester and semesterStep by semester id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateSemesterByIdAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateSemesterByIdAsync$Response(params: {\n    semesterId: string;\n    body?: CreateOrUpdateSemesterRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SemesterResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SemestersService.UpdateSemesterByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('semesterId', params.semesterId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SemesterResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update semester and semesterStep by semester id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateSemesterByIdAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateSemesterByIdAsync(params: {\n    semesterId: string;\n    body?: CreateOrUpdateSemesterRequest\n  },\n  context?: HttpContext\n\n): Observable<SemesterResponse> {\n\n    return this.updateSemesterByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SemesterResponse>) => r.body as SemesterResponse)\n    );\n  }\n\n  /**\n   * Path part for operation searchSemestersBySpecialisationAndProjectIdAsync\n   */\n  static readonly SearchSemestersBySpecialisationAndProjectIdAsyncPath = '/Semesters/search';\n\n  /**\n   * Search semesters by specialisationId, projectId and semester.EndDate => DateTime.Now.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `searchSemestersBySpecialisationAndProjectIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  searchSemestersBySpecialisationAndProjectIdAsync$Plain$Response(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<SemesterSearchResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SemestersService.SearchSemestersBySpecialisationAndProjectIdAsyncPath, 'get');\n    if (params) {\n      rb.query('specialisationId', params.specialisationId, {});\n      rb.query('projectId', params.projectId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<SemesterSearchResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Search semesters by specialisationId, projectId and semester.EndDate => DateTime.Now.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `searchSemestersBySpecialisationAndProjectIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  searchSemestersBySpecialisationAndProjectIdAsync$Plain(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<SemesterSearchResponse>> {\n\n    return this.searchSemestersBySpecialisationAndProjectIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<SemesterSearchResponse>>) => r.body as Array<SemesterSearchResponse>)\n    );\n  }\n\n  /**\n   * Search semesters by specialisationId, projectId and semester.EndDate => DateTime.Now.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `searchSemestersBySpecialisationAndProjectIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  searchSemestersBySpecialisationAndProjectIdAsync$Response(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<SemesterSearchResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SemestersService.SearchSemestersBySpecialisationAndProjectIdAsyncPath, 'get');\n    if (params) {\n      rb.query('specialisationId', params.specialisationId, {});\n      rb.query('projectId', params.projectId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<SemesterSearchResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Search semesters by specialisationId, projectId and semester.EndDate => DateTime.Now.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `searchSemestersBySpecialisationAndProjectIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  searchSemestersBySpecialisationAndProjectIdAsync(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<SemesterSearchResponse>> {\n\n    return this.searchSemestersBySpecialisationAndProjectIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<SemesterSearchResponse>>) => r.body as Array<SemesterSearchResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { SpecialisationResponse } from '../models/specialisation-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SpecialisationsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getAllSpecialisationsAsync\n   */\n  static readonly GetAllSpecialisationsAsyncPath = '/Specialisations';\n\n  /**\n   * Return all specialisations.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllSpecialisationsAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllSpecialisationsAsync$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<SpecialisationResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SpecialisationsService.GetAllSpecialisationsAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<SpecialisationResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Return all specialisations.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllSpecialisationsAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllSpecialisationsAsync$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<SpecialisationResponse>> {\n\n    return this.getAllSpecialisationsAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<SpecialisationResponse>>) => r.body as Array<SpecialisationResponse>)\n    );\n  }\n\n  /**\n   * Return all specialisations.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllSpecialisationsAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllSpecialisationsAsync$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<SpecialisationResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SpecialisationsService.GetAllSpecialisationsAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<SpecialisationResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Return all specialisations.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllSpecialisationsAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllSpecialisationsAsync(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<SpecialisationResponse>> {\n\n    return this.getAllSpecialisationsAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<SpecialisationResponse>>) => r.body as Array<SpecialisationResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { StepTypeResponse } from '../models/step-type-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StepTypesService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getAllStepTypesBySpecialisationIdAsync\n   */\n  static readonly GetAllStepTypesBySpecialisationIdAsyncPath = '/StepTypes';\n\n  /**\n   * Get all stepTypes according to the specialisationId and projectId\n   * Used to generate timeline front.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllStepTypesBySpecialisationIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllStepTypesBySpecialisationIdAsync$Plain$Response(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<StepTypeResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StepTypesService.GetAllStepTypesBySpecialisationIdAsyncPath, 'get');\n    if (params) {\n      rb.query('specialisationId', params.specialisationId, {});\n      rb.query('projectId', params.projectId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<StepTypeResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all stepTypes according to the specialisationId and projectId\n   * Used to generate timeline front.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllStepTypesBySpecialisationIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllStepTypesBySpecialisationIdAsync$Plain(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<StepTypeResponse>> {\n\n    return this.getAllStepTypesBySpecialisationIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<StepTypeResponse>>) => r.body as Array<StepTypeResponse>)\n    );\n  }\n\n  /**\n   * Get all stepTypes according to the specialisationId and projectId\n   * Used to generate timeline front.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllStepTypesBySpecialisationIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllStepTypesBySpecialisationIdAsync$Response(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<StepTypeResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StepTypesService.GetAllStepTypesBySpecialisationIdAsyncPath, 'get');\n    if (params) {\n      rb.query('specialisationId', params.specialisationId, {});\n      rb.query('projectId', params.projectId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<StepTypeResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all stepTypes according to the specialisationId and projectId\n   * Used to generate timeline front.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllStepTypesBySpecialisationIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllStepTypesBySpecialisationIdAsync(params?: {\n    specialisationId?: string;\n    projectId?: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<StepTypeResponse>> {\n\n    return this.getAllStepTypesBySpecialisationIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<StepTypeResponse>>) => r.body as Array<StepTypeResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CreateStepRequest } from '../models/create-step-request';\nimport { StepResponse } from '../models/step-response';\nimport { UpdateStepRequest } from '../models/update-step-request';\nimport { ValidateStepAndNextRequest } from '../models/validate-step-and-next-request';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StepsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation createStepAsync\n   */\n  static readonly CreateStepAsyncPath = '/Steps';\n\n  /**\n   * Create step with data come from CreateStepRequest.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createStepAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createStepAsync$Plain$Response(params?: {\n    body?: CreateStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StepResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StepsService.CreateStepAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StepResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create step with data come from CreateStepRequest.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createStepAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createStepAsync$Plain(params?: {\n    body?: CreateStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StepResponse> {\n\n    return this.createStepAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StepResponse>) => r.body as StepResponse)\n    );\n  }\n\n  /**\n   * Create step with data come from CreateStepRequest.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createStepAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createStepAsync$Response(params?: {\n    body?: CreateStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StepResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StepsService.CreateStepAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StepResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create step with data come from CreateStepRequest.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createStepAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createStepAsync(params?: {\n    body?: CreateStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StepResponse> {\n\n    return this.createStepAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StepResponse>) => r.body as StepResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateStepAsync\n   */\n  static readonly UpdateStepAsyncPath = '/Steps/{stepId}';\n\n  /**\n   * Update step with data come from UpdateStepRequest based on stepId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateStepAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateStepAsync$Plain$Response(params: {\n    stepId: string;\n    body?: UpdateStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StepResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StepsService.UpdateStepAsyncPath, 'put');\n    if (params) {\n      rb.path('stepId', params.stepId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StepResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update step with data come from UpdateStepRequest based on stepId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateStepAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateStepAsync$Plain(params: {\n    stepId: string;\n    body?: UpdateStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StepResponse> {\n\n    return this.updateStepAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StepResponse>) => r.body as StepResponse)\n    );\n  }\n\n  /**\n   * Update step with data come from UpdateStepRequest based on stepId.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateStepAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateStepAsync$Response(params: {\n    stepId: string;\n    body?: UpdateStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StepResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StepsService.UpdateStepAsyncPath, 'put');\n    if (params) {\n      rb.path('stepId', params.stepId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StepResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update step with data come from UpdateStepRequest based on stepId.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateStepAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateStepAsync(params: {\n    stepId: string;\n    body?: UpdateStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StepResponse> {\n\n    return this.updateStepAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StepResponse>) => r.body as StepResponse)\n    );\n  }\n\n  /**\n   * Path part for operation validateStepAndNextAsync\n   */\n  static readonly ValidateStepAndNextAsyncPath = '/Steps/ValidateStepAndNext';\n\n  /**\n   * Validate current step and create next step to facilitate calls by front or BO.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `validateStepAndNextAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  validateStepAndNextAsync$Plain$Response(params?: {\n    body?: ValidateStepAndNextRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StepResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StepsService.ValidateStepAndNextAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StepResponse>;\n      })\n    );\n  }\n\n  /**\n   * Validate current step and create next step to facilitate calls by front or BO.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `validateStepAndNextAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  validateStepAndNextAsync$Plain(params?: {\n    body?: ValidateStepAndNextRequest\n  },\n  context?: HttpContext\n\n): Observable<StepResponse> {\n\n    return this.validateStepAndNextAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StepResponse>) => r.body as StepResponse)\n    );\n  }\n\n  /**\n   * Validate current step and create next step to facilitate calls by front or BO.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `validateStepAndNextAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  validateStepAndNextAsync$Response(params?: {\n    body?: ValidateStepAndNextRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StepResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StepsService.ValidateStepAndNextAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StepResponse>;\n      })\n    );\n  }\n\n  /**\n   * Validate current step and create next step to facilitate calls by front or BO.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `validateStepAndNextAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  validateStepAndNextAsync(params?: {\n    body?: ValidateStepAndNextRequest\n  },\n  context?: HttpContext\n\n): Observable<StepResponse> {\n\n    return this.validateStepAndNextAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StepResponse>) => r.body as StepResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { StudentResponse } from '../models/student-response';\nimport { StudentSearchInfoResponse } from '../models/student-search-info-response';\nimport { StudentSearchResponse } from '../models/student-search-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StudentsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getStudentConnectedAsync\n   */\n  static readonly GetStudentConnectedAsyncPath = '/Students';\n\n  /**\n   * Get student connected.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getStudentConnectedAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getStudentConnectedAsync$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StudentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StudentsService.GetStudentConnectedAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StudentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get student connected.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getStudentConnectedAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getStudentConnectedAsync$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StudentResponse> {\n\n    return this.getStudentConnectedAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StudentResponse>) => r.body as StudentResponse)\n    );\n  }\n\n  /**\n   * Get student connected.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getStudentConnectedAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getStudentConnectedAsync$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StudentResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StudentsService.GetStudentConnectedAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StudentResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get student connected.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getStudentConnectedAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getStudentConnectedAsync(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StudentResponse> {\n\n    return this.getStudentConnectedAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StudentResponse>) => r.body as StudentResponse)\n    );\n  }\n\n  /**\n   * Path part for operation searchStudentsLastNameBeginsWithAsync\n   */\n  static readonly SearchStudentsLastNameBeginsWithAsyncPath = '/Students/search/{lastName}';\n\n  /**\n   * Search all students that LastName begins with\n   * Front autocomplete partnership called this method.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `searchStudentsLastNameBeginsWithAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  searchStudentsLastNameBeginsWithAsync$Plain$Response(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<StudentSearchResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StudentsService.SearchStudentsLastNameBeginsWithAsyncPath, 'get');\n    if (params) {\n      rb.path('lastName', params.lastName, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<StudentSearchResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Search all students that LastName begins with\n   * Front autocomplete partnership called this method.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `searchStudentsLastNameBeginsWithAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  searchStudentsLastNameBeginsWithAsync$Plain(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<StudentSearchResponse>> {\n\n    return this.searchStudentsLastNameBeginsWithAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<StudentSearchResponse>>) => r.body as Array<StudentSearchResponse>)\n    );\n  }\n\n  /**\n   * Search all students that LastName begins with\n   * Front autocomplete partnership called this method.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `searchStudentsLastNameBeginsWithAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  searchStudentsLastNameBeginsWithAsync$Response(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<StudentSearchResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StudentsService.SearchStudentsLastNameBeginsWithAsyncPath, 'get');\n    if (params) {\n      rb.path('lastName', params.lastName, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<StudentSearchResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Search all students that LastName begins with\n   * Front autocomplete partnership called this method.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `searchStudentsLastNameBeginsWithAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  searchStudentsLastNameBeginsWithAsync(params: {\n    lastName: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<StudentSearchResponse>> {\n\n    return this.searchStudentsLastNameBeginsWithAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<StudentSearchResponse>>) => r.body as Array<StudentSearchResponse>)\n    );\n  }\n\n  /**\n   * Path part for operation getStudentInformationsById\n   */\n  static readonly GetStudentInformationsByIdPath = '/Students/{studentId}';\n\n  /**\n   * Get student informations for coordinators with id student.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getStudentInformationsById$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getStudentInformationsById$Plain$Response(params: {\n    studentId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StudentSearchInfoResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StudentsService.GetStudentInformationsByIdPath, 'get');\n    if (params) {\n      rb.path('studentId', params.studentId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StudentSearchInfoResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get student informations for coordinators with id student.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getStudentInformationsById$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getStudentInformationsById$Plain(params: {\n    studentId: string;\n  },\n  context?: HttpContext\n\n): Observable<StudentSearchInfoResponse> {\n\n    return this.getStudentInformationsById$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StudentSearchInfoResponse>) => r.body as StudentSearchInfoResponse)\n    );\n  }\n\n  /**\n   * Get student informations for coordinators with id student.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getStudentInformationsById()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getStudentInformationsById$Response(params: {\n    studentId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StudentSearchInfoResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, StudentsService.GetStudentInformationsByIdPath, 'get');\n    if (params) {\n      rb.path('studentId', params.studentId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StudentSearchInfoResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get student informations for coordinators with id student.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getStudentInformationsById$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getStudentInformationsById(params: {\n    studentId: string;\n  },\n  context?: HttpContext\n\n): Observable<StudentSearchInfoResponse> {\n\n    return this.getStudentInformationsById$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StudentSearchInfoResponse>) => r.body as StudentSearchInfoResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CreateOrUpdateSupervisionRequest } from '../models/create-or-update-supervision-request';\nimport { SupervisionResponse } from '../models/supervision-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SupervisionsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation createSupervisionAsync\n   */\n  static readonly CreateSupervisionAsyncPath = '/Supervisions';\n\n  /**\n   * Create supervision request.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createSupervisionAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createSupervisionAsync$Plain$Response(params?: {\n    body?: CreateOrUpdateSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SupervisionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisionsService.CreateSupervisionAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SupervisionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create supervision request.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createSupervisionAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createSupervisionAsync$Plain(params?: {\n    body?: CreateOrUpdateSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<SupervisionResponse> {\n\n    return this.createSupervisionAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SupervisionResponse>) => r.body as SupervisionResponse)\n    );\n  }\n\n  /**\n   * Create supervision request.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createSupervisionAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createSupervisionAsync$Response(params?: {\n    body?: CreateOrUpdateSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SupervisionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisionsService.CreateSupervisionAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SupervisionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create supervision request.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createSupervisionAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createSupervisionAsync(params?: {\n    body?: CreateOrUpdateSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<SupervisionResponse> {\n\n    return this.createSupervisionAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SupervisionResponse>) => r.body as SupervisionResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateSupervisionByIdAsync\n   */\n  static readonly UpdateSupervisionByIdAsyncPath = '/Supervisions/{supervisionId}';\n\n  /**\n   * Update supervision request.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateSupervisionByIdAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateSupervisionByIdAsync$Plain$Response(params: {\n    supervisionId: string;\n    body?: CreateOrUpdateSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SupervisionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisionsService.UpdateSupervisionByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('supervisionId', params.supervisionId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SupervisionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update supervision request.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateSupervisionByIdAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateSupervisionByIdAsync$Plain(params: {\n    supervisionId: string;\n    body?: CreateOrUpdateSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<SupervisionResponse> {\n\n    return this.updateSupervisionByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SupervisionResponse>) => r.body as SupervisionResponse)\n    );\n  }\n\n  /**\n   * Update supervision request.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateSupervisionByIdAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateSupervisionByIdAsync$Response(params: {\n    supervisionId: string;\n    body?: CreateOrUpdateSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SupervisionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisionsService.UpdateSupervisionByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('supervisionId', params.supervisionId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SupervisionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update supervision request.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateSupervisionByIdAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateSupervisionByIdAsync(params: {\n    supervisionId: string;\n    body?: CreateOrUpdateSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<SupervisionResponse> {\n\n    return this.updateSupervisionByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SupervisionResponse>) => r.body as SupervisionResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CreateOrUpdateExaminationRequest } from '../models/create-or-update-examination-request';\nimport { ExaminationResponse } from '../models/examination-response';\nimport { StepResponse } from '../models/step-response';\nimport { SupervisorIntermediateValidationPciStepRequest } from '../models/supervisor-intermediate-validation-pci-step-request';\nimport { SupervisorValidationStepRequest } from '../models/supervisor-validation-step-request';\nimport { SupervisorValidationStepResponse } from '../models/supervisor-validation-step-response';\nimport { ThesisItemGridResponse } from '../models/thesis-item-grid-response';\nimport { ThesisSupervisorResponse } from '../models/thesis-supervisor-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SupervisorsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation documentStepValidationAsync\n   */\n  static readonly DocumentStepValidationAsyncPath = '/Supervisors';\n\n  /**\n   * Supervisor 's validation (Step and document).\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `documentStepValidationAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  documentStepValidationAsync$Plain$Response(params?: {\n    body?: SupervisorValidationStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SupervisorValidationStepResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.DocumentStepValidationAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SupervisorValidationStepResponse>;\n      })\n    );\n  }\n\n  /**\n   * Supervisor 's validation (Step and document).\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `documentStepValidationAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  documentStepValidationAsync$Plain(params?: {\n    body?: SupervisorValidationStepRequest\n  },\n  context?: HttpContext\n\n): Observable<SupervisorValidationStepResponse> {\n\n    return this.documentStepValidationAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SupervisorValidationStepResponse>) => r.body as SupervisorValidationStepResponse)\n    );\n  }\n\n  /**\n   * Supervisor 's validation (Step and document).\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `documentStepValidationAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  documentStepValidationAsync$Response(params?: {\n    body?: SupervisorValidationStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<SupervisorValidationStepResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.DocumentStepValidationAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<SupervisorValidationStepResponse>;\n      })\n    );\n  }\n\n  /**\n   * Supervisor 's validation (Step and document).\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `documentStepValidationAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  documentStepValidationAsync(params?: {\n    body?: SupervisorValidationStepRequest\n  },\n  context?: HttpContext\n\n): Observable<SupervisorValidationStepResponse> {\n\n    return this.documentStepValidationAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<SupervisorValidationStepResponse>) => r.body as SupervisorValidationStepResponse)\n    );\n  }\n\n  /**\n   * Path part for operation documentsPciStepValidationAsync\n   */\n  static readonly DocumentsPciStepValidationAsyncPath = '/Supervisors';\n\n  /**\n   * Supervisor 's validation for Mini-thesis and project documents.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `documentsPciStepValidationAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  documentsPciStepValidationAsync$Plain$Response(params?: {\n    body?: SupervisorIntermediateValidationPciStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StepResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.DocumentsPciStepValidationAsyncPath, 'patch');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StepResponse>;\n      })\n    );\n  }\n\n  /**\n   * Supervisor 's validation for Mini-thesis and project documents.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `documentsPciStepValidationAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  documentsPciStepValidationAsync$Plain(params?: {\n    body?: SupervisorIntermediateValidationPciStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StepResponse> {\n\n    return this.documentsPciStepValidationAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StepResponse>) => r.body as StepResponse)\n    );\n  }\n\n  /**\n   * Supervisor 's validation for Mini-thesis and project documents.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `documentsPciStepValidationAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  documentsPciStepValidationAsync$Response(params?: {\n    body?: SupervisorIntermediateValidationPciStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<StepResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.DocumentsPciStepValidationAsyncPath, 'patch');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<StepResponse>;\n      })\n    );\n  }\n\n  /**\n   * Supervisor 's validation for Mini-thesis and project documents.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `documentsPciStepValidationAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  documentsPciStepValidationAsync(params?: {\n    body?: SupervisorIntermediateValidationPciStepRequest\n  },\n  context?: HttpContext\n\n): Observable<StepResponse> {\n\n    return this.documentsPciStepValidationAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<StepResponse>) => r.body as StepResponse)\n    );\n  }\n\n  /**\n   * Path part for operation deleteStepCommentAsync\n   */\n  static readonly DeleteStepCommentAsyncPath = '/Supervisors/{commentId}';\n\n  /**\n   * Delete a step comment by id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `deleteStepCommentAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteStepCommentAsync$Plain$Response(params: {\n    commentId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.DeleteStepCommentAsyncPath, 'delete');\n    if (params) {\n      rb.path('commentId', params.commentId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * Delete a step comment by id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `deleteStepCommentAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteStepCommentAsync$Plain(params: {\n    commentId: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.deleteStepCommentAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n  /**\n   * Delete a step comment by id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `deleteStepCommentAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteStepCommentAsync$Response(params: {\n    commentId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.DeleteStepCommentAsyncPath, 'delete');\n    if (params) {\n      rb.path('commentId', params.commentId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * Delete a step comment by id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `deleteStepCommentAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  deleteStepCommentAsync(params: {\n    commentId: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.deleteStepCommentAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n  /**\n   * Path part for operation getThesisSupervisorByIdAsync\n   */\n  static readonly GetThesisSupervisorByIdAsyncPath = '/Supervisors/Thesis/{thesisId}';\n\n  /**\n   * Get thesis by id for supervisor view.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getThesisSupervisorByIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getThesisSupervisorByIdAsync$Plain$Response(params: {\n    thesisId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisSupervisorResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.GetThesisSupervisorByIdAsyncPath, 'get');\n    if (params) {\n      rb.path('thesisId', params.thesisId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisSupervisorResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get thesis by id for supervisor view.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getThesisSupervisorByIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getThesisSupervisorByIdAsync$Plain(params: {\n    thesisId: string;\n  },\n  context?: HttpContext\n\n): Observable<ThesisSupervisorResponse> {\n\n    return this.getThesisSupervisorByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisSupervisorResponse>) => r.body as ThesisSupervisorResponse)\n    );\n  }\n\n  /**\n   * Get thesis by id for supervisor view.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getThesisSupervisorByIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getThesisSupervisorByIdAsync$Response(params: {\n    thesisId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisSupervisorResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.GetThesisSupervisorByIdAsyncPath, 'get');\n    if (params) {\n      rb.path('thesisId', params.thesisId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisSupervisorResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get thesis by id for supervisor view.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getThesisSupervisorByIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getThesisSupervisorByIdAsync(params: {\n    thesisId: string;\n  },\n  context?: HttpContext\n\n): Observable<ThesisSupervisorResponse> {\n\n    return this.getThesisSupervisorByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisSupervisorResponse>) => r.body as ThesisSupervisorResponse)\n    );\n  }\n\n  /**\n   * Path part for operation getAllThesisBySupervisorIdAsync\n   */\n  static readonly GetAllThesisBySupervisorIdAsyncPath = '/Supervisors/Thesis/Grid/{supervisorId}';\n\n  /**\n   * Get all thesis and related data by supervisorId (SectorDirector, Supervisor, co-supervisorId)\n   * used to generate grid supervisors views.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllThesisBySupervisorIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllThesisBySupervisorIdAsync$Plain$Response(params: {\n    supervisorId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ThesisItemGridResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.GetAllThesisBySupervisorIdAsyncPath, 'get');\n    if (params) {\n      rb.path('supervisorId', params.supervisorId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ThesisItemGridResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all thesis and related data by supervisorId (SectorDirector, Supervisor, co-supervisorId)\n   * used to generate grid supervisors views.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllThesisBySupervisorIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllThesisBySupervisorIdAsync$Plain(params: {\n    supervisorId: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<ThesisItemGridResponse>> {\n\n    return this.getAllThesisBySupervisorIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ThesisItemGridResponse>>) => r.body as Array<ThesisItemGridResponse>)\n    );\n  }\n\n  /**\n   * Get all thesis and related data by supervisorId (SectorDirector, Supervisor, co-supervisorId)\n   * used to generate grid supervisors views.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllThesisBySupervisorIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllThesisBySupervisorIdAsync$Response(params: {\n    supervisorId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ThesisItemGridResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.GetAllThesisBySupervisorIdAsyncPath, 'get');\n    if (params) {\n      rb.path('supervisorId', params.supervisorId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ThesisItemGridResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all thesis and related data by supervisorId (SectorDirector, Supervisor, co-supervisorId)\n   * used to generate grid supervisors views.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllThesisBySupervisorIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllThesisBySupervisorIdAsync(params: {\n    supervisorId: string;\n  },\n  context?: HttpContext\n\n): Observable<Array<ThesisItemGridResponse>> {\n\n    return this.getAllThesisBySupervisorIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ThesisItemGridResponse>>) => r.body as Array<ThesisItemGridResponse>)\n    );\n  }\n\n  /**\n   * Path part for operation updateExaminationSupervisorCoordinatorByIdAsync\n   */\n  static readonly UpdateExaminationSupervisorCoordinatorByIdAsyncPath = '/Supervisors/Examination/{examinationId}';\n\n  /**\n   * Update examination Supervisor/Coordinator and create document when exmination is validated.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateExaminationSupervisorCoordinatorByIdAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationSupervisorCoordinatorByIdAsync$Plain$Response(params: {\n    examinationId: string;\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ExaminationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.UpdateExaminationSupervisorCoordinatorByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('examinationId', params.examinationId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ExaminationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update examination Supervisor/Coordinator and create document when exmination is validated.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateExaminationSupervisorCoordinatorByIdAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationSupervisorCoordinatorByIdAsync$Plain(params: {\n    examinationId: string;\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<ExaminationResponse> {\n\n    return this.updateExaminationSupervisorCoordinatorByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ExaminationResponse>) => r.body as ExaminationResponse)\n    );\n  }\n\n  /**\n   * Update examination Supervisor/Coordinator and create document when exmination is validated.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateExaminationSupervisorCoordinatorByIdAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationSupervisorCoordinatorByIdAsync$Response(params: {\n    examinationId: string;\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ExaminationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SupervisorsService.UpdateExaminationSupervisorCoordinatorByIdAsyncPath, 'put');\n    if (params) {\n      rb.path('examinationId', params.examinationId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ExaminationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update examination Supervisor/Coordinator and create document when exmination is validated.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateExaminationSupervisorCoordinatorByIdAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateExaminationSupervisorCoordinatorByIdAsync(params: {\n    examinationId: string;\n    body?: CreateOrUpdateExaminationRequest\n  },\n  context?: HttpContext\n\n): Observable<ExaminationResponse> {\n\n    return this.updateExaminationSupervisorCoordinatorByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ExaminationResponse>) => r.body as ExaminationResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CreateOrUpdateThesisRequest } from '../models/create-or-update-thesis-request';\nimport { ThesisCoordinatorResponse } from '../models/thesis-coordinator-response';\nimport { ThesisDetailsSupervisionResponse } from '../models/thesis-details-supervision-response';\nimport { ThesisResponse } from '../models/thesis-response';\nimport { UpdateThesisStep4Request } from '../models/update-thesis-step-4-request';\nimport { UpdateThesisSupervisionRequest } from '../models/update-thesis-supervision-request';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ThesisService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation createThesisAsync\n   */\n  static readonly CreateThesisAsyncPath = '/Thesis';\n\n  /**\n   * Create thesis with data.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createThesisAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createThesisAsync$Plain$Response(params?: {\n    body?: CreateOrUpdateThesisRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.CreateThesisAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create thesis with data.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createThesisAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createThesisAsync$Plain(params?: {\n    body?: CreateOrUpdateThesisRequest\n  },\n  context?: HttpContext\n\n): Observable<ThesisResponse> {\n\n    return this.createThesisAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisResponse>) => r.body as ThesisResponse)\n    );\n  }\n\n  /**\n   * Create thesis with data.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createThesisAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createThesisAsync$Response(params?: {\n    body?: CreateOrUpdateThesisRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.CreateThesisAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create thesis with data.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createThesisAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createThesisAsync(params?: {\n    body?: CreateOrUpdateThesisRequest\n  },\n  context?: HttpContext\n\n): Observable<ThesisResponse> {\n\n    return this.createThesisAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisResponse>) => r.body as ThesisResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateThesisStep1Async\n   */\n  static readonly UpdateThesisStep1AsyncPath = '/Thesis/{thesisId}/step1';\n\n  /**\n   * Update thesis step1.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateThesisStep1Async$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisStep1Async$Plain$Response(params: {\n    thesisId: string;\n    body?: CreateOrUpdateThesisRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.UpdateThesisStep1AsyncPath, 'put');\n    if (params) {\n      rb.path('thesisId', params.thesisId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update thesis step1.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateThesisStep1Async$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisStep1Async$Plain(params: {\n    thesisId: string;\n    body?: CreateOrUpdateThesisRequest\n  },\n  context?: HttpContext\n\n): Observable<ThesisResponse> {\n\n    return this.updateThesisStep1Async$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisResponse>) => r.body as ThesisResponse)\n    );\n  }\n\n  /**\n   * Update thesis step1.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateThesisStep1Async()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisStep1Async$Response(params: {\n    thesisId: string;\n    body?: CreateOrUpdateThesisRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.UpdateThesisStep1AsyncPath, 'put');\n    if (params) {\n      rb.path('thesisId', params.thesisId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update thesis step1.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateThesisStep1Async$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisStep1Async(params: {\n    thesisId: string;\n    body?: CreateOrUpdateThesisRequest\n  },\n  context?: HttpContext\n\n): Observable<ThesisResponse> {\n\n    return this.updateThesisStep1Async$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisResponse>) => r.body as ThesisResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateThesisStep4Async\n   */\n  static readonly UpdateThesisStep4AsyncPath = '/Thesis/{thesisId}/step4';\n\n  /**\n   * Update thesis step4.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateThesisStep4Async$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisStep4Async$Plain$Response(params: {\n    thesisId: string;\n    body?: UpdateThesisStep4Request\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.UpdateThesisStep4AsyncPath, 'put');\n    if (params) {\n      rb.path('thesisId', params.thesisId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update thesis step4.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateThesisStep4Async$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisStep4Async$Plain(params: {\n    thesisId: string;\n    body?: UpdateThesisStep4Request\n  },\n  context?: HttpContext\n\n): Observable<ThesisResponse> {\n\n    return this.updateThesisStep4Async$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisResponse>) => r.body as ThesisResponse)\n    );\n  }\n\n  /**\n   * Update thesis step4.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateThesisStep4Async()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisStep4Async$Response(params: {\n    thesisId: string;\n    body?: UpdateThesisStep4Request\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.UpdateThesisStep4AsyncPath, 'put');\n    if (params) {\n      rb.path('thesisId', params.thesisId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update thesis step4.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateThesisStep4Async$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisStep4Async(params: {\n    thesisId: string;\n    body?: UpdateThesisStep4Request\n  },\n  context?: HttpContext\n\n): Observable<ThesisResponse> {\n\n    return this.updateThesisStep4Async$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisResponse>) => r.body as ThesisResponse)\n    );\n  }\n\n  /**\n   * Path part for operation getAllThesis\n   */\n  static readonly GetAllThesisPath = '/Thesis/All';\n\n  /**\n   * Get all thesis for Coordinator dashboard.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllThesis$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllThesis$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ThesisCoordinatorResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.GetAllThesisPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ThesisCoordinatorResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all thesis for Coordinator dashboard.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllThesis$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllThesis$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<ThesisCoordinatorResponse>> {\n\n    return this.getAllThesis$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ThesisCoordinatorResponse>>) => r.body as Array<ThesisCoordinatorResponse>)\n    );\n  }\n\n  /**\n   * Get all thesis for Coordinator dashboard.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllThesis()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllThesis$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<ThesisCoordinatorResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.GetAllThesisPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<ThesisCoordinatorResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all thesis for Coordinator dashboard.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllThesis$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllThesis(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<ThesisCoordinatorResponse>> {\n\n    return this.getAllThesis$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<ThesisCoordinatorResponse>>) => r.body as Array<ThesisCoordinatorResponse>)\n    );\n  }\n\n  /**\n   * Path part for operation getThesisDetailsSupervisionCoordinatorByThesisIdAsync\n   */\n  static readonly GetThesisDetailsSupervisionCoordinatorByThesisIdAsyncPath = '/Thesis/{thesisId}/DetailsSupervision';\n\n  /**\n   * Get details thesis supervision by thesis id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain$Response(params: {\n    thesisId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisDetailsSupervisionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.GetThesisDetailsSupervisionCoordinatorByThesisIdAsyncPath, 'get');\n    if (params) {\n      rb.path('thesisId', params.thesisId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisDetailsSupervisionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get details thesis supervision by thesis id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain(params: {\n    thesisId: string;\n  },\n  context?: HttpContext\n\n): Observable<ThesisDetailsSupervisionResponse> {\n\n    return this.getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisDetailsSupervisionResponse>) => r.body as ThesisDetailsSupervisionResponse)\n    );\n  }\n\n  /**\n   * Get details thesis supervision by thesis id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getThesisDetailsSupervisionCoordinatorByThesisIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Response(params: {\n    thesisId: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisDetailsSupervisionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.GetThesisDetailsSupervisionCoordinatorByThesisIdAsyncPath, 'get');\n    if (params) {\n      rb.path('thesisId', params.thesisId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisDetailsSupervisionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get details thesis supervision by thesis id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getThesisDetailsSupervisionCoordinatorByThesisIdAsync(params: {\n    thesisId: string;\n  },\n  context?: HttpContext\n\n): Observable<ThesisDetailsSupervisionResponse> {\n\n    return this.getThesisDetailsSupervisionCoordinatorByThesisIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisDetailsSupervisionResponse>) => r.body as ThesisDetailsSupervisionResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateThesisDetailsSupervisionCoordinatorByThesisIdAsync\n   */\n  static readonly UpdateThesisDetailsSupervisionCoordinatorByThesisIdAsyncPath = '/Thesis/{thesisId}/UpdateDetailsSupervision';\n\n  /**\n   * Update details thesis supervision by thesis id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain$Response(params: {\n    thesisId: string;\n    body?: UpdateThesisSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisDetailsSupervisionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.UpdateThesisDetailsSupervisionCoordinatorByThesisIdAsyncPath, 'put');\n    if (params) {\n      rb.path('thesisId', params.thesisId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisDetailsSupervisionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update details thesis supervision by thesis id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain(params: {\n    thesisId: string;\n    body?: UpdateThesisSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<ThesisDetailsSupervisionResponse> {\n\n    return this.updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisDetailsSupervisionResponse>) => r.body as ThesisDetailsSupervisionResponse)\n    );\n  }\n\n  /**\n   * Update details thesis supervision by thesis id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateThesisDetailsSupervisionCoordinatorByThesisIdAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Response(params: {\n    thesisId: string;\n    body?: UpdateThesisSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ThesisDetailsSupervisionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ThesisService.UpdateThesisDetailsSupervisionCoordinatorByThesisIdAsyncPath, 'put');\n    if (params) {\n      rb.path('thesisId', params.thesisId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ThesisDetailsSupervisionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update details thesis supervision by thesis id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateThesisDetailsSupervisionCoordinatorByThesisIdAsync(params: {\n    thesisId: string;\n    body?: UpdateThesisSupervisionRequest\n  },\n  context?: HttpContext\n\n): Observable<ThesisDetailsSupervisionResponse> {\n\n    return this.updateThesisDetailsSupervisionCoordinatorByThesisIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ThesisDetailsSupervisionResponse>) => r.body as ThesisDetailsSupervisionResponse)\n    );\n  }\n\n}\n","<button\n  *ngIf=\"!stroked\"\n  mat-button\n  [class.mat-flat-button]=\"stroked\"\n  [ngClass]=\"isValid ? 'isValid' : 'notValid'\"\n  [type]=\"type\"\n  [disabled]=\"disabled\"\n  extended\n  matTooltipHideDelay=\"300\"\n  [matTooltipClass]=\"customTooltip\"\n  [matTooltipDisabled]=\"!tooltipContent\"\n  [matTooltip]=\"tooltipContent\"\n  [matTooltipPosition]=\"tooltipPosition\"\n  (click)=\"emitClick()\">\n  <mat-icon aria-hidden=\"true\" *ngIf=\"iconName\">{{ iconName }}</mat-icon>\n  <span>{{ name }} </span>\n</button>\n\n<button\n  *ngIf=\"stroked\"\n  mat-flat-button\n  color=\"primary\"\n  [class.mat-flat-button]=\"stroked\"\n  [ngClass]=\"isValid ? 'isValid' : 'notValid'\"\n  [type]=\"type\"\n  [disabled]=\"disabled\"\n  extended\n  matTooltipHideDelay=\"300\"\n  [matTooltipClass]=\"customTooltip\"\n  [matTooltipDisabled]=\"!tooltipContent\"\n  [matTooltip]=\"tooltipContent\"\n  [matTooltipPosition]=\"tooltipPosition\"\n  (click)=\"emitClick()\">\n  <mat-icon aria-hidden=\"true\" *ngIf=\"iconName\">{{ iconName }}</mat-icon>\n  <span>{{ name }} </span>\n</button>\n","import { Component, Input, Output, EventEmitter } from '@angular/core';\nimport { TooltipPosition } from '@angular/material/tooltip';\n\n@Component({\n  selector: 'app-button',\n  templateUrl: './button.component.html',\n  styleUrls: ['./button.component.scss'],\n})\nexport class ButtonComponent {\n  @Input() name!: string;\n  @Input() disabled = false;\n  @Input() stroked = true;\n  @Input() isValid = false;\n  @Input() iconName!: string;\n  @Input() customTooltip!: string;\n  @Input() tooltipContent!: string;\n  @Input() tooltipPosition: TooltipPosition = 'above';\n  @Input() type = 'button';\n  @Output() readonly clickCallbackFn = new EventEmitter<void>();\n\n  emitClick() {\n    this.clickCallbackFn.emit();\n  }\n}\n","<div *ngIf=\"loading\" class=\"lds-ellipsis\">\n  <div></div>\n  <div></div>\n  <div></div>\n  <div></div>\n</div>\n","import { Component, Input } from '@angular/core';\n\n@Component({\n  selector: 'app-horizontal-loader',\n  templateUrl: './horizontal-loader.component.html',\n  styleUrls: ['./horizontal-loader.component.scss'],\n})\nexport class ProfileLoaderComponent {\n  @Input() loading = false;\n}\n","/** * Decorator to place on a Component to automatically free its subscriptions upon component destruction * It prevents huge memory leak, performance issues and unexpected behaviors of the application */\nexport function AutoUnsubscribe() {\n  return (constructor: any) => {\n    // Saving the original `ngOnDestroy` method\n    const originalOnDestroy = constructor.prototype.ngOnDestroy;\n    constructor.prototype.ngOnDestroy = function () {\n      for (const prop in this) {\n        if (Object.hasOwnProperty.call(this, prop)) {\n          const property = this[prop];\n          if (property && typeof property.unsubscribe === 'function') {\n            property.unsubscribe();\n          }\n        }\n      }\n      // Running the originalOnDestroy `ngOnDestroy` method\n      if (originalOnDestroy) {\n        originalOnDestroy.apply(this);\n      }\n    };\n  };\n}\n","export enum Roles {\n  SectorDirector = 'SECTOR_DIRECTOR',\n  Supervisor = 'SUPERVISOR',\n  CoSupervisor = 'CO_SUPERVISOR',\n  Professor = 'PROFESSOR',\n  Student = 'STUDENT',\n  Coordinator = 'COORDINATOR',\n  CoordinatorAdmin = 'COORDINATOR_ADMIN',\n}\n","export enum Specialisation {\n  CLASSIQUE = 'CLASSIQUE',\n  EDI = 'EDI',\n  ALTERNANCE = 'ALTERNANCE',\n}\n","import { Injectable } from '@angular/core';\nimport { MatSnackBar, MatSnackBarConfig } from '@angular/material/snack-bar';\nimport { TranslateService } from '@ngx-translate/core';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class NotificationService {\n  defaultDuration = 2000;\n\n  configuration = {\n    horizontalPosition: 'center',\n    verticalPosition: 'bottom',\n  } as MatSnackBarConfig;\n\n  constructor(private _snackBar: MatSnackBar, private translateService: TranslateService) {}\n\n  error(message: string) {\n    return this._snackBar.open(this.translateService.instant(message), undefined, {\n      panelClass: ['snackbar-error'],\n      duration: 3000,\n      ...this.configuration,\n    });\n  }\n\n  success(message: string) {\n    return this._snackBar.open(this.translateService.instant(message), undefined, {\n      panelClass: ['snackbar-success'],\n      duration: this.defaultDuration,\n      ...this.configuration,\n    });\n  }\n\n  info(message: string) {\n    return this._snackBar.open(this.translateService.instant(message), undefined, {\n      panelClass: ['snackbar-info'],\n      duration: this.defaultDuration,\n      ...this.configuration,\n    });\n  }\n}\n","import { NgModule } from '@angular/core';\nimport { MatSelectModule } from '@angular/material/select';\nimport { MatRippleModule } from '@angular/material/core';\nimport { MatDatepickerModule } from '@angular/material/datepicker';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatInputModule } from '@angular/material/input';\nimport { MAT_DATE_LOCALE } from '@angular/material/core';\nimport { MatDialogModule, MatDialogRef } from '@angular/material/dialog';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatTableModule } from '@angular/material/table';\nimport { MatSortModule } from '@angular/material/sort';\nimport { MatPaginatorModule } from '@angular/material/paginator';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatTreeModule } from '@angular/material/tree';\nimport { CdkAccordionModule } from '@angular/cdk/accordion';\nimport { MatTooltipModule } from '@angular/material/tooltip';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { MatCheckboxModule } from '@angular/material/checkbox';\nimport { MatAutocompleteModule } from '@angular/material/autocomplete';\nimport { MatCardModule } from '@angular/material/card';\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\nimport { MatTabsModule } from '@angular/material/tabs';\nimport { MatSnackBarModule } from '@angular/material/snack-bar';\nimport { MatButtonToggleModule } from '@angular/material/button-toggle';\nimport { MatRadioModule } from '@angular/material/radio';\nimport { MatStepperModule } from '@angular/material/stepper';\nimport { MatChipsModule } from '@angular/material/chips';\nimport { MatMomentDateModule } from '@angular/material-moment-adapter';\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\n\n@NgModule({\n  exports: [\n    MatChipsModule,\n    MatRippleModule,\n    MatButtonToggleModule,\n    MatRadioModule,\n    MatStepperModule,\n    MatSnackBarModule,\n    MatTabsModule,\n    MatProgressBarModule,\n    MatCardModule,\n    MatCheckboxModule,\n    MatMenuModule,\n    MatIconModule,\n    MatSelectModule,\n    MatDatepickerModule,\n    MatMomentDateModule,\n    MatFormFieldModule,\n    MatInputModule,\n    MatDialogModule,\n    MatButtonModule,\n    MatTableModule,\n    MatSortModule,\n    MatPaginatorModule,\n    MatIconModule,\n    MatTreeModule,\n    CdkAccordionModule,\n    MatTooltipModule,\n    MatAutocompleteModule,\n    MatProgressSpinnerModule,\n  ],\n  providers: [\n    { provide: MAT_DATE_LOCALE, useValue: 'fr-FR' },\n    { provide: MatDialogRef, useValue: {} },\n  ],\n})\nexport class MaterialModule {}\n","import { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ButtonComponent } from './components/button/button.component';\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\nimport { SelectComponent } from '@sharedComponents/select/select.component';\nimport { MaterialModule } from './material.module';\nimport { DialogComponent } from '@sharedComponents/dialog/dialog.component';\nimport { HeaderComponent } from '@sharedComponents/header/header.component';\nimport { ProfileMenuComponent } from '@sharedComponents/profile-menu/profile-menu.component';\nimport { LanguageSwitchComponent } from '@sharedComponents/language-switch/language-switch.component';\nimport { FilesUploaderComponent } from '@sharedComponents/files-uploader/files-uploader.component';\nimport { DragAndDropDirective } from './directives/draganddrop.directive';\nimport { ProfileLoaderComponent } from '@sharedComponents/horizontal-loader/horizontal-loader.component';\nimport { LoaderComponent } from '@sharedComponents/loader/loader.component';\nimport { ValidationWarningComponent } from '@sharedComponents/validation-warning/validation-warning.component';\nimport { DepositFileComponent } from '@sharedComponents/deposit-file/deposit-file.component';\nimport { ValidationComponent } from '@sharedComponents/validation/validation.component';\nimport { MessageComponent } from '@sharedComponents/message/message.component';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { DynamicFormComponent } from '@sharedComponents/dynamic-form/dynamic-form.component';\nimport { FooterComponent } from '@sharedComponents/footer/footer.component';\nimport { StepTitleComponent } from '@sharedComponents/step-title/step-title.component';\nimport { InformationsPanelComponent } from '@sharedComponents/informations-panel/informations-panel.component';\nimport { IconButtonComponent } from '@sharedComponents/icon-button/icon-button.component';\nimport { TimelineComponent } from './components/timeline/timeline.component';\nimport { FinalDocIconComponent } from '@sharedComponents/final-doc-icon/final-doc-icon.component';\nimport { NumbersOnlyDirective } from './directives/numbers-only.directive';\nimport { UnauthorizedComponent } from '@sharedComponents/unauthorized/unauthorized.component';\nimport { BreadcrumbComponent } from '@sharedComponents/breadcrumb/breadcrumb.component';\nimport { StepNavigatorComponent } from '@sharedComponents/step-navigator/step-navigator.component';\nimport { DocumentsTableComponent } from '@sharedComponents/documents-table/documents-table.component';\nimport { ResearchSpinnerComponent } from '@sharedComponents/research-spinner/research-spinner.component';\n\n@NgModule({\n  imports: [CommonModule, FormsModule, ReactiveFormsModule, MaterialModule, TranslateModule.forChild()],\n  declarations: [\n    ResearchSpinnerComponent,\n    DocumentsTableComponent,\n    StepNavigatorComponent,\n    BreadcrumbComponent,\n    UnauthorizedComponent,\n    FinalDocIconComponent,\n    IconButtonComponent,\n    InformationsPanelComponent,\n    StepTitleComponent,\n    FooterComponent,\n    DynamicFormComponent,\n    ValidationComponent,\n    DepositFileComponent,\n    ValidationWarningComponent,\n    MessageComponent,\n    DragAndDropDirective,\n    FilesUploaderComponent,\n    ProfileLoaderComponent,\n    LoaderComponent,\n    LanguageSwitchComponent,\n    ProfileMenuComponent,\n    DialogComponent,\n    ButtonComponent,\n    SelectComponent,\n    HeaderComponent,\n    LoaderComponent,\n    TimelineComponent,\n    NumbersOnlyDirective,\n  ],\n  exports: [\n    ResearchSpinnerComponent,\n    DocumentsTableComponent,\n    StepNavigatorComponent,\n    BreadcrumbComponent,\n    FinalDocIconComponent,\n    IconButtonComponent,\n    InformationsPanelComponent,\n    StepTitleComponent,\n    DynamicFormComponent,\n    FooterComponent,\n    ValidationComponent,\n    DepositFileComponent,\n    ValidationWarningComponent,\n    MessageComponent,\n    LoaderComponent,\n    ProfileLoaderComponent,\n    FilesUploaderComponent,\n    LanguageSwitchComponent,\n    ProfileMenuComponent,\n    ButtonComponent,\n    SelectComponent,\n    HeaderComponent,\n    DialogComponent,\n    FormsModule,\n    ReactiveFormsModule,\n    MaterialModule,\n    CommonModule,\n    TimelineComponent,\n    NumbersOnlyDirective,\n  ],\n})\nexport class SharedModule {}\n","import { Component } from '@angular/core';\n\n@Component({\n  selector: 'app-unauthorized',\n  templateUrl: './unauthorized.component.html',\n  styleUrls: ['./unauthorized.component.scss']\n})\nexport class UnauthorizedComponent {\n\n}\n","<mat-card>\n  <mat-card-header>\n    <div mat-card-avatar>\n      <img src=\"/assets/img/picto-warning.svg\" />\n    </div>\n    <mat-card-title>{{ 'ERROR.UNAUTHORIZED' | translate }}</mat-card-title>\n  </mat-card-header>\n  <mat-card-content>\n    <p>{{ 'ERROR.UNAUTHORIZED_MESSAGE' | translate }}</p>\n  </mat-card-content>\n</mat-card>\n","import { Inject, Injectable } from '@angular/core';\nimport {\n  IPublicClientApplication,\n  AccountInfo,\n  EndSessionRequest,\n  AuthorizationUrlRequest,\n  AuthenticationResult,\n  RedirectRequest,\n  SilentRequest,\n  PopupRequest,\n} from '@azure/msal-browser';\nimport { Observable, from } from 'rxjs';\nimport { Location } from '@angular/common';\nimport { IAuthenticationService } from './IAuthenticationService';\nimport { MSAL_INSTANCE } from '@azure/msal-angular';\n\n@Injectable()\nexport class AuthenticationService implements IAuthenticationService {\n  private redirectHash = '';\n\n  constructor(\n    @Inject(MSAL_INSTANCE)\n    public instance: IPublicClientApplication,\n    private location: Location\n  ) {\n    // Cache the code hash before Angular router clears it\n    const hash = this.location.path(true).split('#').pop();\n    if (hash) {\n      this.redirectHash = `#${hash}`;\n    }\n  }\n\n  acquireTokenPopup(request: PopupRequest): Observable<AuthenticationResult> {\n    return from(this.instance.acquireTokenPopup(request));\n  }\n  acquireTokenRedirect(request: RedirectRequest): Observable<void> {\n    return from(this.instance.acquireTokenRedirect(request));\n  }\n  acquireTokenSilent(silentRequest: SilentRequest): Observable<AuthenticationResult> {\n    return from(this.instance.acquireTokenSilent(silentRequest));\n  }\n  getAllAccounts(): AccountInfo[] {\n    return this.instance.getAllAccounts();\n  }\n  logoutRedirect(request?: EndSessionRequest): Observable<void> {\n    return from(this.instance.logoutRedirect(request));\n  }\n  logout(logoutRequest?: EndSessionRequest): Observable<void> {\n    return from(this.instance.logout(logoutRequest));\n  }\n}\n","import { BrowserCacheLocation } from '@azure/msal-browser';\nimport { environmentModel } from '../app/core/models/environment.model';\n\nconst isIE = window.navigator.userAgent.indexOf('MSIE ') > -1 || window.navigator.userAgent.indexOf('Trident/') > -1;\n\nexport const environment: environmentModel = {\n  production: true,\n  mode: 'integration',\n  baseUri: '#{baseUri}#',\n  apiUri: '#{apiUri}#',\n  authentication: {\n    clientId: '#{clientId}#',\n    redirectUri: '#{redirectUri}#',\n    authority: '#{authority}#',\n    postLogoutRedirectUri: '#{redirectUri}#',\n    navigateToLoginRequestUrl: true,\n  },\n  appInsights: {\n    instrumentationKey: '#{instrumentationKey}#',\n  },\n  cache: {\n    cacheLocation: BrowserCacheLocation.LocalStorage,\n    storeAuthStateInCookie: isIE,\n  },\n  scope: '#{scope}#',\n};\n","import { Injectable } from '@angular/core';\nimport { ApplicationInsights } from '@microsoft/applicationinsights-web';\nimport { environment } from 'src/environments/environment';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class MonitoringService {\n  appInsights: ApplicationInsights;\n  constructor() {\n    this.appInsights = new ApplicationInsights({\n      config: {\n        instrumentationKey: environment.appInsights.instrumentationKey,\n        enableCorsCorrelation: true,\n        disableTelemetry: environment.mode == 'dev',\n        enableAutoRouteTracking: true, // option to log all route changes\n      },\n    });\n    this.appInsights.loadAppInsights();\n  }\n\n  logPageView(name?: string, url?: string) {\n    this.appInsights.trackPageView({\n      name: name,\n      uri: url,\n    });\n  }\n\n  logEvent(name: string, properties?: { [key: string]: any }) {\n    this.appInsights.trackEvent({ name: name }, properties);\n  }\n\n  logMetric(name: string, average: number, properties?: { [key: string]: any }) {\n    this.appInsights.trackMetric({ name: name, average: average }, properties);\n  }\n\n  logException(exception: Error, severityLevel?: number) {\n    this.appInsights.trackException({ exception: exception, severityLevel: severityLevel });\n  }\n\n  logTrace(message: string, properties?: { [key: string]: any }) {\n    this.appInsights.trackTrace({ message: message }, properties);\n  }\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { UserResponse } from '../models/user-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class UsersService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getUserAsync\n   */\n  static readonly GetUserAsyncPath = '/Users';\n\n  /**\n   * Get user and roles.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getUserAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getUserAsync$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<UserResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, UsersService.GetUserAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<UserResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get user and roles.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getUserAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getUserAsync$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<UserResponse> {\n\n    return this.getUserAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<UserResponse>) => r.body as UserResponse)\n    );\n  }\n\n  /**\n   * Get user and roles.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getUserAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getUserAsync$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<UserResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, UsersService.GetUserAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<UserResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get user and roles.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getUserAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getUserAsync(params?: {\n  },\n  context?: HttpContext\n\n): Observable<UserResponse> {\n\n    return this.getUserAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<UserResponse>) => r.body as UserResponse)\n    );\n  }\n\n}\n","import { UserState } from 'src/store/user/user.states';\nimport { inject } from '@angular/core';\nimport { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from '@angular/router';\nimport { Store } from '@ngrx/store';\nimport { Roles } from '@sharedEnums/roles.enum';\nimport { UserResponse } from '@sharedModels/user-response';\nimport { map } from 'rxjs';\nimport * as userReducer from 'src/store/user/user.reducer';\n\nexport const SUPERVISOR_ROLES = [Roles.Supervisor, Roles.CoSupervisor, Roles.SectorDirector];\nexport const COORDINATOR_ROLES = [Roles.Coordinator, Roles.CoordinatorAdmin];\n\n/**\n * Checks if the user has the necessary roles to access a specific route.\n * * This method satisfies the `CanActivateFn` type from Angular's router.\n * * See https://angular.io/api/router/CanActivateFn\n *\n * @return An observable that emits true if the user has the necessary roles, false otherwise.\n */\nexport function RolesGuard(route: ActivatedRouteSnapshot, _2: RouterStateSnapshot, userStore = inject(Store<UserState>), router = inject(Router)) {\n  return userStore.select(userReducer.getUser).pipe(\n    map((user: UserResponse) => {\n      if (!user || !user.id) {\n        return false;\n      }\n\n      // Use the route config path to determine where user wants to navigate\n      const goingToStudentPages = route.routeConfig?.path === 'student';\n      const goingToSupervisorPages = route.routeConfig?.path === 'supervisor';\n      const goingToCoordinatorPages = route.routeConfig?.path === 'coordinator';\n\n      const userRoles = user.roles?.map(a => a.userRole) ?? [];\n      const canActivateStudentPages = canActivateStudent(userRoles);\n      const canActivateSupervisorPages = canActivateSupervisor(userRoles);\n      const canActivateCoordinatorPages = canActivateCoordinator(userRoles);\n\n      if (canActivateStudentPages && !goingToStudentPages) {\n        return router.parseUrl('/student');\n      } else if (canActivateSupervisorPages && !goingToSupervisorPages) {\n        return router.parseUrl('/supervisor');\n      } else if (canActivateCoordinatorPages && !goingToCoordinatorPages) {\n        return router.parseUrl('/coordinator');\n      } else if (!canActivateCoordinatorPages && !canActivateStudentPages && !canActivateSupervisorPages) {\n        return router.parseUrl('/unauthorized');\n      }\n\n      return true;\n    })\n  );\n}\n\n/**\n * Determines if a user can activate as a student.\n *\n * @param userRoles - The roles of the user.\n * @return A boolean value indicating if the user can activate as a student.\n */\nfunction canActivateStudent(userRoles: (string | null | undefined)[]) {\n  const studentRole = userRoles.find(role => role === Roles.Student);\n  if (studentRole && userRoles.length == 1) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Determines if a user can activate as a supervisor.\n *\n * @param userRoles - The roles of the user.\n * @return A boolean value indicating if the user can activate as a supervisor.\n */\nfunction canActivateSupervisor(userRoles: (string | null | undefined)[]) {\n  if (userRoles.includes(Roles.Student)) {\n    return false;\n  }\n\n  if (userRoles.some(role => SUPERVISOR_ROLES.includes(role as Roles))) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Determines if a user can activate as a coordinator.\n *\n * @param userRoles - The roles of the user.\n * @return A boolean value indicating if the user can activate as a coordinator.\n */\nfunction canActivateCoordinator(userRoles: (string | null | undefined)[]) {\n  if (userRoles.some(role => COORDINATOR_ROLES.includes(role as Roles))) {\n    return true;\n  }\n  return false;\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { CoordinatorResponse } from '../models/coordinator-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CoordinatorsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getCoordinatorConnectedAsync\n   */\n  static readonly GetCoordinatorConnectedAsyncPath = '/Coordinators';\n\n  /**\n   * Get coordinator connected.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getCoordinatorConnectedAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCoordinatorConnectedAsync$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<CoordinatorResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CoordinatorsService.GetCoordinatorConnectedAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<CoordinatorResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get coordinator connected.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getCoordinatorConnectedAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCoordinatorConnectedAsync$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<CoordinatorResponse> {\n\n    return this.getCoordinatorConnectedAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<CoordinatorResponse>) => r.body as CoordinatorResponse)\n    );\n  }\n\n  /**\n   * Get coordinator connected.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getCoordinatorConnectedAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCoordinatorConnectedAsync$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<CoordinatorResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, CoordinatorsService.GetCoordinatorConnectedAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<CoordinatorResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get coordinator connected.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getCoordinatorConnectedAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getCoordinatorConnectedAsync(params?: {\n  },\n  context?: HttpContext\n\n): Observable<CoordinatorResponse> {\n\n    return this.getCoordinatorConnectedAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<CoordinatorResponse>) => r.body as CoordinatorResponse)\n    );\n  }\n\n}\n","import { inject } from '@angular/core';\nimport { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from '@angular/router';\nimport { MsalBroadcastService } from '@azure/msal-angular';\nimport { AccountInfo, InteractionStatus } from '@azure/msal-browser';\nimport { AuthenticationService } from '@coreServices/authenticationService/authentication.service';\nimport { Store } from '@ngrx/store';\nimport { filter, forkJoin, map, of, switchMap, take, tap } from 'rxjs';\nimport { UserState } from 'src/store/user/user.states';\nimport * as userReducer from 'src/store/user/user.reducer';\nimport { UserResponse } from '@sharedModels/user-response';\nimport { MonitoringService } from '@coreServices/monitoringService/monitoring.service';\nimport { UsersService } from '@sharedServices/users.service';\nimport { environment } from 'src/environments/environment';\nimport GlobalStorageService from '@coreServices/globalStorageService';\nimport { UserActions } from 'src/store/user/user.actions';\nimport { StudentsService } from '@sharedServices/students.service';\nimport { ProfessorsService } from '@sharedServices/professors.service';\nimport { Roles } from '@sharedEnums/roles.enum';\nimport { StudentState } from 'src/store/student/student.states';\nimport { SupervisorState } from 'src/store/supervisor/supervisor.states';\nimport { StudentActions } from 'src/store/student/student.actions';\nimport { SupervisorActions } from 'src/store/supervisor/supervisor.actions';\nimport { COORDINATOR_ROLES, SUPERVISOR_ROLES } from './roles.guard';\nimport { CoordinatorState } from 'src/store/coordinator/coordinator.states';\nimport { CoordinatorsService } from '@sharedServices/coordinators.service';\nimport { CoordinatorActions } from 'src/store/coordinator/coordinator.actions';\n\n/**\n * Acts as an authentication guard.\n * * This method satisfies the `CanActivateFn` type from Angular's router.\n * * See https://angular.io/api/router/CanActivateFn\n *\n * @return An observable that emits a boolean indicating whether the user can access the route.\n */\nexport function AuthGuard(\n  route: ActivatedRouteSnapshot,\n  state: RouterStateSnapshot,\n  broadcastService = inject(MsalBroadcastService),\n  userStore = inject(Store<UserState>),\n  authenticationService = inject(AuthenticationService),\n  monitoringService = inject(MonitoringService),\n  usersService = inject(UsersService),\n  globalStorageService = inject(GlobalStorageService),\n  studentsService = inject(StudentsService),\n  professorsService = inject(ProfessorsService),\n  coordinatorsService = inject(CoordinatorsService),\n  studentStore = inject(Store<StudentState>),\n  supervisorStore = inject(Store<SupervisorState>),\n  coordinatorStore = inject(Store<CoordinatorState>),\n  router = inject(Router)\n) {\n  return broadcastService.inProgress$.pipe(\n    filter((status: InteractionStatus) => status === InteractionStatus.None),\n    take(1),\n    switchMap(() => {\n      const account = authenticationService.instance.getAllAccounts()[0];\n      if (!account) {\n        monitoringService.logEvent('user is not logged');\n        return of(false);\n      }\n\n      monitoringService.logEvent('user is logged');\n\n      // If there is an account, we check the user and get his roles.\n      return checkUser(userStore, account, authenticationService, globalStorageService, usersService).pipe(\n        switchMap(user => {\n          // If user is null, it means the user is already in store so no need to get user role again.\n          if (!user) {\n            return of(true);\n          }\n\n          return getUserRole(user, studentsService, coordinatorsService, studentStore, supervisorStore, coordinatorStore, professorsService).pipe(\n            map(() => {\n              // Navigate to url in state to not lose user navigation\n              return router.parseUrl(state.url);\n            })\n          );\n        })\n      );\n    })\n  );\n}\n\n/**\n * Checks the user's information and retrieves the user data from the user store.\n * * If user is not present in the user store, it will going to get the authentication token then get user.\n * * Else it will return null.\n *\n * @param userStore - The store that holds the user state.\n * @param account - The account information of the user.\n * @param authenticationService - The service responsible for authentication.\n * @param globalStorageService - The service responsible for global storage.\n * @param usersService - The service responsible for managing users.\n * @return An observable that emits the user data or null.\n */\nfunction checkUser(\n  userStore: Store<UserState>,\n  account: AccountInfo,\n  authenticationService: AuthenticationService,\n  globalStorageService: GlobalStorageService,\n  usersService: UsersService\n) {\n  return userStore.select(userReducer.getUser).pipe(\n    take(1),\n    switchMap(user => {\n      if (!user || !user.id) {\n        // Get token then get user and return user\n        return forkJoin([getToken(authenticationService, account, globalStorageService), getUser(usersService, userStore)]).pipe(map(([_, user]) => user));\n      } else {\n        return of(null);\n      }\n    })\n  );\n}\n\n/**\n * Retrieves a token using the authentication service and account information and store it in the global storage.\n *\n * @param authenticationService - The authentication service used to acquire the token.\n * @param account - The account information used to acquire the token.\n * @param globalStorageService - The global storage service used to store the token.\n * @return An observable that emits when the token is successfully acquired and stored.\n */\nfunction getToken(authenticationService: AuthenticationService, account: AccountInfo, globalStorageService: GlobalStorageService) {\n  const accessTokenRequest = {\n    scopes: [environment.scope],\n    account,\n  };\n  return authenticationService.acquireTokenSilent(accessTokenRequest).pipe(map(result => globalStorageService.setToken(result.accessToken)));\n}\n\n/**\n * Retrieves a user from the users service and dispatches it to the user store.\n *\n * @param usersService - The service used to retrieve the user.\n * @param userStore - The store used to dispatch the user.\n * @return An observable that emits the user.\n */\nfunction getUser(usersService: UsersService, userStore: Store<UserState>) {\n  return usersService.getUserAsync().pipe(\n    tap(user => {\n      if (user) {\n        userStore.dispatch(UserActions.setUser(user));\n      }\n    })\n  );\n}\n\n/**\n * Saves the user by his roles.\n *\n * @param user - The user response object containing user information.\n * @param studentsService - The service responsible for handling student-related operations.\n * @param studentStore - The store for managing student state.\n * @param supervisorStore - The store for managing supervisor state.\n * @param professorsService - The service responsible for handling professor-related operations.\n * @return An observable that emits a boolean indicating whether the user role was successfully retrieved.\n */\nfunction getUserRole(\n  user: UserResponse,\n  studentsService: StudentsService,\n  coordinatorsService: CoordinatorsService,\n  studentStore: Store<StudentState>,\n  supervisorStore: Store<SupervisorState>,\n  coordinatorStore: Store<CoordinatorState>,\n  professorsService: ProfessorsService\n) {\n  if (user.roles?.some(role => role.userRole === Roles.Student)) {\n    return saveStudent(studentsService, studentStore);\n  }\n\n  if (user.roles?.some(role => SUPERVISOR_ROLES.includes(role.userRole as Roles))) {\n    return saveSupervisor(professorsService, supervisorStore);\n  }\n\n  if (user.roles?.some(role => COORDINATOR_ROLES.includes(role.userRole as Roles))) {\n    return saveCoordinator(coordinatorsService, coordinatorStore);\n  }\n\n  return of(false);\n}\n\n/**\n * Saves the student by dispatching the student to the student store.\n *\n * @param studentsService - The service for retrieving connected student.\n * @param studentStore - The store for managing student state.\n * @return An observable that emits a boolean indicating if the student exists.\n */\nfunction saveStudent(studentsService: StudentsService, studentStore: Store<StudentState>) {\n  return studentsService.getStudentConnectedAsync().pipe(\n    map(student => {\n      if (student) {\n        studentStore.dispatch(StudentActions.setStudentData(student));\n      }\n\n      return !!student;\n    })\n  );\n}\n\n/**\n * Saves the supervisor by dispatching the professor to the supervisor store.\n *\n * @param professorsService - The service for retrieving connected professor.\n * @param supervisorStore - The store for managing supervisor state.\n * @return An observable that emits a boolean indicating if the professor exists.\n */\nfunction saveSupervisor(professorsService: ProfessorsService, supervisorStore: Store<SupervisorState>) {\n  return professorsService.getProfessorConnectedAsync().pipe(\n    map(professor => {\n      if (professor) {\n        supervisorStore.dispatch(SupervisorActions.setSupervisor(professor));\n      }\n\n      return !!professor;\n    })\n  );\n}\n\n/**\n * Saves the coordinator by dispatching into the coordinator store.\n *\n * @param professorsService - The service for retrieving connected professor.\n * @param supervisorStore - The store for managing supervisor state.\n * @return An observable that emits a boolean indicating if the professor exists.\n */\nfunction saveCoordinator(coordinatorsService: CoordinatorsService, coordinatorStore: Store<CoordinatorState>) {\n  return coordinatorsService.getCoordinatorConnectedAsync().pipe(\n    map(coordinator => {\n      if (coordinator) {\n        coordinatorStore.dispatch(CoordinatorActions.setCoordinator(coordinator));\n      }\n\n      return !!coordinator;\n    })\n  );\n}\n","import { NgModule } from '@angular/core';\nimport { RouterModule, Routes } from '@angular/router';\nimport { MsalGuard } from '@azure/msal-angular';\nimport { BrowserUtils } from '@azure/msal-browser';\nimport { UnauthorizedComponent } from '@sharedComponents/unauthorized/unauthorized.component';\nimport { AuthGuard } from './core/guards/auth.guard';\nimport { RolesGuard } from './core/guards/roles.guard';\n\nconst routes: Routes = [\n  { path: 'unauthorized', component: UnauthorizedComponent, title: 'Unauthorized' },\n  {\n    path: 'supervisor',\n    canActivate: [MsalGuard, AuthGuard, RolesGuard],\n    loadChildren: () => import('./views/supervisor/supervisor.module').then(a => a.SupervisorModule),\n  },\n  {\n    path: 'coordinator',\n    canActivate: [MsalGuard, AuthGuard, RolesGuard],\n    loadChildren: () => import('./views/coordinator/coordinator.module').then(a => a.CoordinatorModule),\n  },\n  {\n    path: 'student',\n    canActivate: [MsalGuard, AuthGuard, RolesGuard],\n    loadChildren: () => import('./views/student/student.module').then(a => a.StudentModule),\n  },\n  { path: '**', redirectTo: 'student' },\n];\n\n@NgModule({\n  imports: [\n    RouterModule.forRoot(routes, {\n      // Don't perform initial navigation in iframes or popups\n      initialNavigation: !BrowserUtils.isInIframe() && !BrowserUtils.isInPopup() ? 'enabledNonBlocking' : 'disabled', // Set to enabledBlocking to use Angular Universal\n    }),\n  ],\n  exports: [RouterModule],\n})\nexport class AppRoutingModule {}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { ArbitrationResponse } from '../models/arbitration-response';\nimport { CreateOrUpdateArbitrationRequest } from '../models/create-or-update-arbitration-request';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ArbitrationsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getArbitrationByIdAsync\n   */\n  static readonly GetArbitrationByIdAsyncPath = '/Arbitrations';\n\n  /**\n   * Get arbitration by id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getArbitrationByIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getArbitrationByIdAsync$Plain$Response(params?: {\n    arbitrationId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ArbitrationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ArbitrationsService.GetArbitrationByIdAsyncPath, 'get');\n    if (params) {\n      rb.query('arbitrationId', params.arbitrationId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ArbitrationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get arbitration by id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getArbitrationByIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getArbitrationByIdAsync$Plain(params?: {\n    arbitrationId?: string;\n  },\n  context?: HttpContext\n\n): Observable<ArbitrationResponse> {\n\n    return this.getArbitrationByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ArbitrationResponse>) => r.body as ArbitrationResponse)\n    );\n  }\n\n  /**\n   * Get arbitration by id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getArbitrationByIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getArbitrationByIdAsync$Response(params?: {\n    arbitrationId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ArbitrationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ArbitrationsService.GetArbitrationByIdAsyncPath, 'get');\n    if (params) {\n      rb.query('arbitrationId', params.arbitrationId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ArbitrationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Get arbitration by id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getArbitrationByIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getArbitrationByIdAsync(params?: {\n    arbitrationId?: string;\n  },\n  context?: HttpContext\n\n): Observable<ArbitrationResponse> {\n\n    return this.getArbitrationByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ArbitrationResponse>) => r.body as ArbitrationResponse)\n    );\n  }\n\n  /**\n   * Path part for operation updateArbitrationByIdAsync\n   */\n  static readonly UpdateArbitrationByIdAsyncPath = '/Arbitrations';\n\n  /**\n   * Update arbitration by id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateArbitrationByIdAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateArbitrationByIdAsync$Plain$Response(params?: {\n    arbitrationId?: string;\n    body?: CreateOrUpdateArbitrationRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ArbitrationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ArbitrationsService.UpdateArbitrationByIdAsyncPath, 'put');\n    if (params) {\n      rb.query('arbitrationId', params.arbitrationId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ArbitrationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update arbitration by id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateArbitrationByIdAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateArbitrationByIdAsync$Plain(params?: {\n    arbitrationId?: string;\n    body?: CreateOrUpdateArbitrationRequest\n  },\n  context?: HttpContext\n\n): Observable<ArbitrationResponse> {\n\n    return this.updateArbitrationByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ArbitrationResponse>) => r.body as ArbitrationResponse)\n    );\n  }\n\n  /**\n   * Update arbitration by id.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `updateArbitrationByIdAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateArbitrationByIdAsync$Response(params?: {\n    arbitrationId?: string;\n    body?: CreateOrUpdateArbitrationRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ArbitrationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ArbitrationsService.UpdateArbitrationByIdAsyncPath, 'put');\n    if (params) {\n      rb.query('arbitrationId', params.arbitrationId, {});\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ArbitrationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Update arbitration by id.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `updateArbitrationByIdAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  updateArbitrationByIdAsync(params?: {\n    arbitrationId?: string;\n    body?: CreateOrUpdateArbitrationRequest\n  },\n  context?: HttpContext\n\n): Observable<ArbitrationResponse> {\n\n    return this.updateArbitrationByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ArbitrationResponse>) => r.body as ArbitrationResponse)\n    );\n  }\n\n  /**\n   * Path part for operation createArbitrationAsync\n   */\n  static readonly CreateArbitrationAsyncPath = '/Arbitrations';\n\n  /**\n   * Create arbitration.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createArbitrationAsync$Plain()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createArbitrationAsync$Plain$Response(params?: {\n    body?: CreateOrUpdateArbitrationRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ArbitrationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ArbitrationsService.CreateArbitrationAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ArbitrationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create arbitration.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createArbitrationAsync$Plain$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createArbitrationAsync$Plain(params?: {\n    body?: CreateOrUpdateArbitrationRequest\n  },\n  context?: HttpContext\n\n): Observable<ArbitrationResponse> {\n\n    return this.createArbitrationAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ArbitrationResponse>) => r.body as ArbitrationResponse)\n    );\n  }\n\n  /**\n   * Create arbitration.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `createArbitrationAsync()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createArbitrationAsync$Response(params?: {\n    body?: CreateOrUpdateArbitrationRequest\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ArbitrationResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ArbitrationsService.CreateArbitrationAsyncPath, 'post');\n    if (params) {\n      rb.body(params.body, 'application/*+json');\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ArbitrationResponse>;\n      })\n    );\n  }\n\n  /**\n   * Create arbitration.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `createArbitrationAsync$Response()` instead.\n   *\n   * This method sends `application/*+json` and handles request body of type `application/*+json`.\n   */\n  createArbitrationAsync(params?: {\n    body?: CreateOrUpdateArbitrationRequest\n  },\n  context?: HttpContext\n\n): Observable<ArbitrationResponse> {\n\n    return this.createArbitrationAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ArbitrationResponse>) => r.body as ArbitrationResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { ImportAurionResponse } from '../models/import-aurion-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ImportAurionService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation importAurionGet\n   */\n  static readonly ImportAurionGetPath = '/ImportAurion';\n\n  /**\n   * Execute import aurion.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `importAurionGet$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  importAurionGet$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ImportAurionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ImportAurionService.ImportAurionGetPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ImportAurionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Execute import aurion.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `importAurionGet$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  importAurionGet$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<ImportAurionResponse> {\n\n    return this.importAurionGet$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ImportAurionResponse>) => r.body as ImportAurionResponse)\n    );\n  }\n\n  /**\n   * Execute import aurion.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `importAurionGet()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  importAurionGet$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<ImportAurionResponse>> {\n\n    const rb = new RequestBuilder(this.rootUrl, ImportAurionService.ImportAurionGetPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<ImportAurionResponse>;\n      })\n    );\n  }\n\n  /**\n   * Execute import aurion.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `importAurionGet$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  importAurionGet(params?: {\n  },\n  context?: HttpContext\n\n): Observable<ImportAurionResponse> {\n\n    return this.importAurionGet$Response(params,context).pipe(\n      map((r: StrictHttpResponse<ImportAurionResponse>) => r.body as ImportAurionResponse)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { SectorResponse } from '../models/sector-response';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SectorsService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation getAllSectorsAsync\n   */\n  static readonly GetAllSectorsAsyncPath = '/Sectors';\n\n  /**\n   * Get all sectors.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllSectorsAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllSectorsAsync$Plain$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<SectorResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SectorsService.GetAllSectorsAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<SectorResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all sectors.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllSectorsAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllSectorsAsync$Plain(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<SectorResponse>> {\n\n    return this.getAllSectorsAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<SectorResponse>>) => r.body as Array<SectorResponse>)\n    );\n  }\n\n  /**\n   * Get all sectors.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `getAllSectorsAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllSectorsAsync$Response(params?: {\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<Array<SectorResponse>>> {\n\n    const rb = new RequestBuilder(this.rootUrl, SectorsService.GetAllSectorsAsyncPath, 'get');\n    if (params) {\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return r as StrictHttpResponse<Array<SectorResponse>>;\n      })\n    );\n  }\n\n  /**\n   * Get all sectors.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `getAllSectorsAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  getAllSectorsAsync(params?: {\n  },\n  context?: HttpContext\n\n): Observable<Array<SectorResponse>> {\n\n    return this.getAllSectorsAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<Array<SectorResponse>>) => r.body as Array<SectorResponse>)\n    );\n  }\n\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpResponse, HttpContext } from '@angular/common/http';\nimport { BaseService } from '../base-service';\nimport { ApiConfiguration } from '../api-configuration';\nimport { StrictHttpResponse } from '../strict-http-response';\nimport { RequestBuilder } from '../request-builder';\nimport { Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TestModesService extends BaseService {\n  constructor(\n    config: ApiConfiguration,\n    http: HttpClient\n  ) {\n    super(config, http);\n  }\n\n  /**\n   * Path part for operation testModeStudentSwitchSpecialisationAsync\n   */\n  static readonly TestModeStudentSwitchSpecialisationAsyncPath = '/TestModes';\n\n  /**\n   * ENABLED INTEGRATION/DEBUG ONLY (use appsettings.json to enable or not this feature)\n   * Allow user to clean data and switch profile (EDI, CLASSIQUE, ALTERNANCE).\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `testModeStudentSwitchSpecialisationAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  testModeStudentSwitchSpecialisationAsync$Plain$Response(params?: {\n    studentId?: string;\n    thesisId?: string;\n    specialisationCode?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, TestModesService.TestModeStudentSwitchSpecialisationAsyncPath, 'post');\n    if (params) {\n      rb.query('studentId', params.studentId, {});\n      rb.query('thesisId', params.thesisId, {});\n      rb.query('specialisationCode', params.specialisationCode, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * ENABLED INTEGRATION/DEBUG ONLY (use appsettings.json to enable or not this feature)\n   * Allow user to clean data and switch profile (EDI, CLASSIQUE, ALTERNANCE).\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `testModeStudentSwitchSpecialisationAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  testModeStudentSwitchSpecialisationAsync$Plain(params?: {\n    studentId?: string;\n    thesisId?: string;\n    specialisationCode?: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.testModeStudentSwitchSpecialisationAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n  /**\n   * ENABLED INTEGRATION/DEBUG ONLY (use appsettings.json to enable or not this feature)\n   * Allow user to clean data and switch profile (EDI, CLASSIQUE, ALTERNANCE).\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `testModeStudentSwitchSpecialisationAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  testModeStudentSwitchSpecialisationAsync$Response(params?: {\n    studentId?: string;\n    thesisId?: string;\n    specialisationCode?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, TestModesService.TestModeStudentSwitchSpecialisationAsyncPath, 'post');\n    if (params) {\n      rb.query('studentId', params.studentId, {});\n      rb.query('thesisId', params.thesisId, {});\n      rb.query('specialisationCode', params.specialisationCode, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * ENABLED INTEGRATION/DEBUG ONLY (use appsettings.json to enable or not this feature)\n   * Allow user to clean data and switch profile (EDI, CLASSIQUE, ALTERNANCE).\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `testModeStudentSwitchSpecialisationAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  testModeStudentSwitchSpecialisationAsync(params?: {\n    studentId?: string;\n    thesisId?: string;\n    specialisationCode?: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.testModeStudentSwitchSpecialisationAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n  /**\n   * Path part for operation testModeDeleteThesisByIdAsync\n   */\n  static readonly TestModeDeleteThesisByIdAsyncPath = '/TestModes';\n\n  /**\n   * ENABLED INTEGRATION/DEBUG ONLY (use appsettings.json to enable or not this feature)\n   * Delete thesis and all data attached.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `testModeDeleteThesisByIdAsync$Plain()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  testModeDeleteThesisByIdAsync$Plain$Response(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, TestModesService.TestModeDeleteThesisByIdAsyncPath, 'delete');\n    if (params) {\n      rb.query('thesisId', params.thesisId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'text',\n      accept: 'text/plain',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * ENABLED INTEGRATION/DEBUG ONLY (use appsettings.json to enable or not this feature)\n   * Delete thesis and all data attached.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `testModeDeleteThesisByIdAsync$Plain$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  testModeDeleteThesisByIdAsync$Plain(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.testModeDeleteThesisByIdAsync$Plain$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n  /**\n   * ENABLED INTEGRATION/DEBUG ONLY (use appsettings.json to enable or not this feature)\n   * Delete thesis and all data attached.\n   *\n   *\n   *\n   * This method provides access to the full `HttpResponse`, allowing access to response headers.\n   * To access only the response body, use `testModeDeleteThesisByIdAsync()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  testModeDeleteThesisByIdAsync$Response(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<StrictHttpResponse<boolean>> {\n\n    const rb = new RequestBuilder(this.rootUrl, TestModesService.TestModeDeleteThesisByIdAsyncPath, 'delete');\n    if (params) {\n      rb.query('thesisId', params.thesisId, {});\n    }\n\n    return this.http.request(rb.build({\n      responseType: 'json',\n      accept: 'text/json',\n      context: context\n    })).pipe(\n      filter((r: any) => r instanceof HttpResponse),\n      map((r: HttpResponse<any>) => {\n        return (r as HttpResponse<any>).clone({ body: String((r as HttpResponse<any>).body) === 'true' }) as StrictHttpResponse<boolean>;\n      })\n    );\n  }\n\n  /**\n   * ENABLED INTEGRATION/DEBUG ONLY (use appsettings.json to enable or not this feature)\n   * Delete thesis and all data attached.\n   *\n   *\n   *\n   * This method provides access only to the response body.\n   * To access the full response (for headers, for example), `testModeDeleteThesisByIdAsync$Response()` instead.\n   *\n   * This method doesn't expect any request body.\n   */\n  testModeDeleteThesisByIdAsync(params?: {\n    thesisId?: string;\n  },\n  context?: HttpContext\n\n): Observable<boolean> {\n\n    return this.testModeDeleteThesisByIdAsync$Response(params,context).pipe(\n      map((r: StrictHttpResponse<boolean>) => r.body as boolean)\n    );\n  }\n\n}\n","import { Component, OnInit } from '@angular/core';\nimport { frenchIcon, ukIcon } from './languages-icons';\nimport { TranslateService } from '@ngx-translate/core';\n\n@Component({\n  selector: 'app-language-switch',\n  templateUrl: './language-switch.component.html',\n  styleUrls: ['./language-switch.component.scss'],\n})\nexport class LanguageSwitchComponent implements OnInit {\n  frIcon!: string;\n  ukIcon!: string;\n  defaultIsSelected = true;\n\n  constructor(private translate: TranslateService) {}\n  ngOnInit(): void {\n    this.frIcon = frenchIcon.selectedValue;\n    this.ukIcon = ukIcon.unSelectedValue;\n    this.changeLanguage(document.documentElement.lang);\n  }\n\n  changeLanguage(language: string) {\n    document.documentElement.lang = language;\n    if (language == 'fr') {\n      this.defaultIsSelected = true;\n      this.frIcon = frenchIcon.selectedValue;\n      this.ukIcon = ukIcon.unSelectedValue;\n    } else {\n      this.defaultIsSelected = false;\n      this.frIcon = frenchIcon.unSelectedValue;\n      this.ukIcon = ukIcon.selectedValue;\n    }\n    this.translate.use(language);\n  }\n}\n","interface LanguageIcon {\n  selectedValue: string;\n  unSelectedValue: string;\n}\n\nexport const frenchIcon: LanguageIcon = {\n  selectedValue: 'assets/img/fr-selected-icon.svg',\n  unSelectedValue: 'assets/img/fr-unselected-icon.svg',\n};\n\nexport const ukIcon: LanguageIcon = {\n  selectedValue: 'assets/img/uk-selected-icon.svg',\n  unSelectedValue: 'assets/img/uk-unselected-icon.svg',\n};\n","<div class=\"languages-container\">\n  <div class=\"fr-container\">\n    <span [ariaSelected]=\"defaultIsSelected\" aria-label=\"french translation\" class=\"language-switch\" (click)=\"changeLanguage('fr')\">\n      <img src=\"{{ frIcon }}\" width=\"20\" height=\"14\"\n    /></span>\n    FR\n  </div>\n  <div class=\"uk-container\">\n    <span [ariaSelected]=\"!defaultIsSelected\" aria-label=\"english translation\" class=\"language-switch\" (click)=\"changeLanguage('en')\">\n      <img src=\"{{ ukIcon }}\" width=\"20\" height=\"14\" />\n      EN\n    </span>\n  </div>\n</div>\n","<div>\n  <div class=\"profile-container\" *ngIf=\"!loading\">\n    <div class=\"user-icon\">\n      <div class=\"icon\">\n        {{ initials }}\n      </div>\n    </div>\n    <div>{{ fullName }}</div>\n    <div class=\"disconnect-btn\" matTooltip=\"Disconnect\" (click)=\"logout()\">\n      <img src=\"/assets/img/logout.svg\" />\n    </div>\n  </div>\n  <app-horizontal-loader [loading]=\"loading\"></app-horizontal-loader>\n  <span *ngIf=\"!userExist && !loading\" class=\"disconnected\">Vous êtes déconnectés</span>\n</div>\n","import { Component, OnInit } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { UserState } from 'src/store/user/user.states';\nimport * as userReducer from 'src/store/user/user.reducer';\nimport { AuthenticationService } from '@coreServices/authenticationService/authentication.service';\nimport { Subscription, map } from 'rxjs';\nimport { AutoUnsubscribe } from '../../decorators/autoUnsubscribe';\n\n@Component({\n  selector: 'app-profilemenu',\n  templateUrl: './profile-menu.component.html',\n  styleUrls: ['./profile-menu.component.scss'],\n})\n@AutoUnsubscribe()\nexport class ProfileMenuComponent implements OnInit {\n  userExist = false;\n  loading = true;\n  fullName = '';\n  initials = '';\n  getUserSubscribe = new Subscription();\n\n  constructor(private userStore: Store<UserState>, private authenticationService: AuthenticationService) {}\n\n  ngOnInit(): void {\n    this.getUserSubscribe.add(\n      this.userStore\n        .select(userReducer.getUser)\n        .pipe(\n          map(result => {\n            if (result && result.firstName) {\n              this.fullName = `${result.firstName} ${result.lastName}`;\n              this.initials = `${result.firstName?.charAt(0)}${result.lastName?.charAt(0)}`;\n              this.userExist = true;\n              this.loading = false;\n            }\n          })\n        )\n        .subscribe()\n    );\n  }\n\n  logout(): void {\n    this.authenticationService.logoutRedirect();\n  }\n}\n","<header class=\"header\">\n  <div class=\"header-logo show_element\">\n    <button (click)=\"goHome()\">\n      <img src=\"assets/img/logo.svg\" height=\"60\" width=\"160\" />\n    </button>\n  </div>\n  <div class=\"header-informations\" [class.coordinator]=\"coordinatorMode\">\n    <div *ngIf=\"!coordinatorMode && studentSpecialisation && studentSpecialisation !== specialisationEnum.EDI\" class=\"header-projects\">\n      <button class=\"btn-projects\" mat-stroked-button>\n        {{ 'CATALOG' | translate }}\n      </button>\n    </div>\n    <div *ngIf=\"coordinatorMode\" class=\"coordinator-menu show_element\">\n      <button mat-stroked-button [color]=\"'primary'\" *ngFor=\"let item of coordinatorMenu\" (click)=\"gotoPage(item)\">{{ item | translate }}</button>\n    </div>\n    <div class=\"other-menu show_element\">\n      <div *ngIf=\"!coordinatorMode\" class=\"header-languages\">\n        <app-language-switch></app-language-switch>\n      </div>\n      <div *ngIf=\"!coordinatorMode\" class=\"separator\"></div>\n      <div class=\"header-profile\">\n        <app-profilemenu></app-profilemenu>\n      </div>\n    </div>\n  </div>\n</header>\n","import { Component, OnInit } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { Store } from '@ngrx/store';\nimport { Roles } from '@sharedEnums/roles.enum';\nimport { Specialisation } from '@sharedEnums/specialisation.enum';\nimport { Subscription } from 'rxjs';\nimport { getStudent } from 'src/store/student/student.reducer';\nimport { StudentState } from 'src/store/student/student.states';\nimport { getUser } from 'src/store/user/user.reducer';\nimport { UserState } from 'src/store/user/user.states';\n\nexport const COORDINATOR_ROLES = [Roles.Coordinator, Roles.CoordinatorAdmin];\nexport const SUPERVISOR_ROLES = [Roles.Supervisor, Roles.CoSupervisor, Roles.SectorDirector];\n@Component({\n  selector: 'app-header',\n  templateUrl: './header.component.html',\n  styleUrls: ['./header.component.scss'],\n})\nexport class HeaderComponent implements OnInit {\n  constructor(private router: Router, private userStore: Store<UserState>, private studentStore: Store<StudentState>) {}\n  headerSubscription = new Subscription();\n  studentSpecialisation!: string;\n  specialisationEnum = Specialisation;\n  coordinatorMenu = ['HOME', 'PROFESSORS', 'STUDENTS', 'SEMESTER'];\n  supervisorMode!: boolean;\n  coordinatorMode!: boolean;\n  studentMode!: boolean;\n\n  ngOnInit(): void {\n    this.headerSubscription.add(\n      this.userStore.select(getUser).subscribe(user => {\n        if (user && user.roles) {\n          this.coordinatorMode = user.roles.map(a => a.userRole).some(role => COORDINATOR_ROLES.includes(role as Roles));\n          this.supervisorMode = user.roles.map(a => a.userRole).some(role => SUPERVISOR_ROLES.includes(role as Roles));\n          this.studentMode = user.roles.map(a => a.userRole).some(role => role == Roles.Student);\n        }\n        if (this.studentMode) {\n          this.studentStore.select(getStudent).subscribe(result => {\n            if (result.specialisation) this.studentSpecialisation = result.specialisation.name;\n          });\n        }\n      })\n    );\n  }\n\n  gotoPage(item: string) {\n    this.router.navigate(['coordinator', item.toLowerCase()]);\n  }\n\n  goHome() {\n    if (this.coordinatorMode) {\n      this.router.navigate(['coordinator']);\n      return;\n    }\n    if (this.supervisorMode) {\n      this.router.navigate(['supervisor']);\n      return;\n    }\n    this.router.navigate(['student']);\n  }\n}\n","<div id=\"app-wrapper\">\n  <div *ngIf=\"testMode && currentStudent.id\" class=\"mode-test\">\n    <span class=\"title\">Test Mode</span>\n    <div *ngIf=\"currentEnv == 'dev'\">\n      <p>\n        <app-button [isValid]=\"true\" name=\"Supprimer la thèse\" (clickCallbackFn)=\"deleteThesis()\"></app-button>\n      </p>\n      <p>\n        <app-button [isValid]=\"true\" name=\"Valider l'étape et passer à la suivante\" (clickCallbackFn)=\"validateStep()\"></app-button>\n      </p>\n      <p>\n        <app-button [isValid]=\"true\" name=\"Refuser l'étape\" (clickCallbackFn)=\"refuseStep()\"></app-button>\n      </p>\n      <p>\n        <app-button [isValid]=\"true\" name=\"Parcours Classique\" (clickCallbackFn)=\"switchSpecialization(Specialisation.CLASSIQUE)\"></app-button>\n      </p>\n      <p>\n        <app-button [isValid]=\"true\" name=\"Parcours Alternance\" (clickCallbackFn)=\"switchSpecialization(Specialisation.ALTERNANCE)\"></app-button>\n      </p>\n    </div>\n    <p>\n      <app-button [isValid]=\"true\" name=\"Parcours EDI\" (clickCallbackFn)=\"switchSpecialization(Specialisation.EDI)\"></app-button>\n    </p>\n    <p class=\"result\">\n      {{ operationResult }}\n    </p>\n  </div>\n  <app-header></app-header>\n  <main id=\"main-container\">\n    <router-outlet></router-outlet>\n  </main>\n</div>\n","import { Component, OnInit } from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { Store } from '@ngrx/store';\nimport { UserState } from 'src/store/user/user.states';\nimport { MsalBroadcastService } from '@azure/msal-angular';\nimport { environment } from 'src/environments/environment';\nimport GlobalStorageService from '@coreServices/globalStorageService';\nimport { StepsService, TestModesService } from './shared/api/services';\nimport { EnumStepStatus, StudentResponse, UserResponse } from './shared/api/models';\nimport { Specialisation } from '@sharedEnums/specialisation.enum';\nimport { StudentState } from 'src/store/student/student.states';\nimport * as studentReducer from 'src/store/student/student.reducer';\nimport { AutoUnsubscribe } from './shared/decorators/autoUnsubscribe';\nimport { getUser } from 'src/store/user/user.reducer';\n\n@Component({\n  selector: 'app-root',\n  templateUrl: './app.component.html',\n  styleUrls: ['./app.component.scss'],\n})\n@AutoUnsubscribe()\nexport class AppComponent implements OnInit {\n  testMode = false;\n  currentUser!: UserResponse;\n  currentStudent!: StudentResponse;\n  operationResult = '';\n  currentEnv!: string;\n  public Specialisation = Specialisation;\n\n  private readonly subscription = new Subscription();\n\n  constructor(\n    private broadcastService: MsalBroadcastService,\n    private globalStorageService: GlobalStorageService,\n    private userStore: Store<UserState>,\n    private studentStore: Store<StudentState>,\n    private stepsService: StepsService,\n    private readonly testModesService: TestModesService\n  ) {}\n\n  ngOnInit(): void {\n    this.currentEnv = environment.mode;\n    this.testMode = this.currentEnv == 'dev'; // || this.currentEnv == 'integration'; // Uncomment to get testMode\n\n    this.subscription.add(\n      this.userStore.select(getUser).subscribe(user => {\n        this.currentUser = user;\n      })\n    );\n\n    this.subscription.add(\n      this.studentStore.select(studentReducer.getStudent).subscribe(result => {\n        this.currentStudent = result;\n      })\n    );\n  }\n\n  validateStep() {\n    if (this.currentStudent?.currentStepId) {\n      this.stepsService.validateStepAndNextAsync({ body: { currentStepId: this.currentStudent.currentStepId } }).subscribe(result => {\n        if (result) {\n          this.globalStorageService.updateStudentCurrentStepAndDispatchToStore(this.currentStudent, result);\n          this.reloadStep();\n        }\n      });\n    } else {\n      location.reload();\n    }\n  }\n\n  /**\n   * Deletes current user thesis.\n   *  * Only for test purpose\n   */\n  deleteThesis() {\n    const thesisId = this.currentStudent?.thesis?.id;\n    if (thesisId)\n      this.testModesService.testModeDeleteThesisByIdAsync({ thesisId }).subscribe(result => {\n        if (result) this.reloadStep();\n      });\n  }\n\n  refuseStep() {\n    if (this.currentStudent?.currentStepId)\n      this.stepsService\n        .updateStepAsync({\n          stepId: this.currentStudent.currentStepId,\n          body: { stepStatus: EnumStepStatus.Refused },\n        })\n        .subscribe(result => {\n          if (result) this.reloadStep();\n        });\n  }\n\n  /**\n   * Switches the current user's specialization.\n   *  * Only for test purpose\n   *\n   * @param specialisation - The new specialization to switch to.\n   */\n  public switchSpecialization(specialisation: Specialisation) {\n    if (this.currentStudent) {\n      this.testModesService\n        .testModeStudentSwitchSpecialisationAsync({\n          studentId: this.currentStudent.id,\n          thesisId: this.currentStudent.thesis?.id,\n          specialisationCode: specialisation,\n        })\n        .subscribe(result => {\n          if (result) this.reloadStep();\n        });\n    }\n  }\n\n  reloadStep() {\n    this.operationResult = 'Opération réussie';\n    setTimeout(() => {\n      this.operationResult = 'Opération réussie';\n    }, 600);\n    setTimeout(() => {\n      location.reload();\n    }, 1200);\n  }\n}\n","import { Minimatch } from 'minimatch';\nimport { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor } from '@angular/common/http';\nimport { Observable, EMPTY } from 'rxjs';\nimport { switchMap, catchError } from 'rxjs/operators';\nimport { AuthenticationResult, InteractionType } from '@azure/msal-browser';\nimport { Injectable, Inject } from '@angular/core';\nimport { AuthenticationService } from './authentication.service';\nimport { MSAL_INTERCEPTOR_CONFIG } from '@azure/msal-angular';\nimport { MsalInterceptorConfiguration } from './msal.interceptor.configuration';\n\n@Injectable()\nexport class MsalInterceptor implements HttpInterceptor {\n  constructor(@Inject(MSAL_INTERCEPTOR_CONFIG) private msalInterceptorConfig: MsalInterceptorConfiguration, private authService: AuthenticationService) {}\n\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n    const scopes = this.getScopesForEndpoint(req.url);\n    const account = this.authService.getAllAccounts()[0];\n\n    if (!scopes || scopes.length === 0) {\n      return next.handle(req);\n    }\n\n    // Note: For MSA accounts, include openid scope when calling acquireTokenSilent to return idToken\n    return this.authService.acquireTokenSilent({ scopes, account }).pipe(\n      catchError(() => {\n        if (this.msalInterceptorConfig.interactionType === InteractionType.Popup) {\n          return this.authService.acquireTokenPopup({ ...this.msalInterceptorConfig.authRequest, scopes });\n        }\n        const redirectStartPage = window.location.href;\n        this.authService.acquireTokenRedirect({ ...this.msalInterceptorConfig.authRequest, scopes, redirectStartPage });\n        return EMPTY;\n      }),\n      switchMap((result: AuthenticationResult) => {\n        const headers = req.headers.set('Authorization', `Bearer ${result.accessToken}`);\n\n        const requestClone = req.clone({ headers });\n        return next.handle(requestClone);\n      })\n    );\n  }\n\n  private getScopesForEndpoint(endpoint: string): Array<string> | undefined {\n    const protectedResourcesArray = Array.from(this.msalInterceptorConfig.protectedResourceMap.keys());\n\n    const keyMatchesEndpointArray = protectedResourcesArray.filter(key => {\n      const minimatch = new Minimatch(key);\n      return minimatch.match(endpoint) || endpoint.indexOf(key) > -1;\n    });\n\n    // process all protected resources and send the first matched resource\n    if (keyMatchesEndpointArray.length > 0) {\n      const keyForEndpoint = keyMatchesEndpointArray[0];\n      if (keyForEndpoint) {\n        return this.msalInterceptorConfig.protectedResourceMap.get(keyForEndpoint);\n      }\n    }\n\n    return undefined;\n  }\n}\n","import { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { HTTP_INTERCEPTORS } from '@angular/common/http';\nimport {\n  MSAL_GUARD_CONFIG,\n  MSAL_INSTANCE,\n  MSAL_INTERCEPTOR_CONFIG,\n  MsalBroadcastService,\n  MsalGuard,\n  MsalGuardConfiguration,\n  MsalModule,\n  MsalService,\n} from '@azure/msal-angular';\nimport { PublicClientApplication, InteractionType } from '@azure/msal-browser';\nimport { environment } from 'src/environments/environment';\nimport { MsalInterceptorConfiguration } from './msal.interceptor.configuration';\nimport { AuthenticationService } from './authentication.service';\nimport { MsalInterceptor } from './msal.interceptor';\n\n@NgModule({\n  declarations: [],\n  imports: [CommonModule, MsalModule],\n  providers: [\n    {\n      provide: HTTP_INTERCEPTORS,\n      useClass: MsalInterceptor,\n      multi: true,\n    },\n    {\n      provide: MSAL_INSTANCE,\n      useFactory: () => new PublicClientApplication({ auth: environment.authentication }),\n    },\n    {\n      provide: MSAL_GUARD_CONFIG,\n      useValue: {\n        interactionType: InteractionType.Redirect,\n      } as MsalGuardConfiguration,\n    },\n    {\n      provide: MSAL_INTERCEPTOR_CONFIG,\n      useFactory: () =>\n        ({\n          interactionType: InteractionType.Redirect,\n          protectedResourceMap: new Map<string, Array<string>>([[environment.apiUri, [environment.scope]]]),\n        } as MsalInterceptorConfiguration),\n    },\n    AuthenticationService,\n    MsalService,\n    MsalBroadcastService,\n    MsalGuard,\n  ],\n})\nexport class AuthenticationModule {}\n","import { Action, ActionReducer, ActionReducerMap } from '@ngrx/store';\nimport { AppState } from './app.states';\nimport { userReducer } from '../user/user.reducer';\nimport { UserState } from '../user/user.states';\nimport { thesisSupervisorReducer } from '../thesis/thesis.reducer';\nimport { studentReducer } from '../student/student.reducer';\nimport { ThesisSupervisorState } from '../thesis/thesis.states';\nimport { StudentState } from '../student/student.states';\nimport { supervisorReducer } from '../supervisor/supervisor.reducer';\nimport { SupervisorState } from '../supervisor/supervisor.states';\nimport { ThesisTimelineState } from '../thesis-timeline/thesis-timeline.states';\nimport { thesisTimelineReducer } from '../thesis-timeline/thesis-timeline.reducer';\nimport { coordinatorReducer } from '../coordinator/coordinator.reducer';\nimport { CoordinatorState } from '../coordinator/coordinator.states';\n\nexport const appReducer: ActionReducerMap<AppState> = {\n  userState: userReducer as ActionReducer<UserState, Action>,\n  thesisSupervisorState: thesisSupervisorReducer as ActionReducer<ThesisSupervisorState, Action>,\n  studentState: studentReducer as ActionReducer<StudentState, Action>,\n  thesisTimelineState: thesisTimelineReducer as ActionReducer<ThesisTimelineState, Action>,\n  supervisorState: supervisorReducer as ActionReducer<SupervisorState, Action>,\n  coordinatorState: coordinatorReducer as ActionReducer<CoordinatorState, Action>,\n};\n","import { NgModule } from '@angular/core';\nimport { StoreModule } from '@ngrx/store';\nimport { HttpClientModule } from '@angular/common/http';\n\nimport { AuthenticationModule } from '@coreServices/authenticationService/authentication.module';\nimport { MonitoringService } from '@coreServices/monitoringService/monitoring.service';\nimport StorageService from '@coreServices/globalStorageService';\nimport { appReducer } from 'src/store/app/app.reducer';\n\n@NgModule({\n  declarations: [],\n  imports: [HttpClientModule, AuthenticationModule, StoreModule.forRoot(appReducer)],\n  providers: [StorageService, MonitoringService],\n})\nexport class CoreModule {}\n","import { ErrorHandler, Injectable } from '@angular/core';\nimport { MonitoringService } from '@coreServices/monitoringService/monitoring.service';\nimport { NotificationService } from '@sharedServices/notification.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ErrorHandlerService extends ErrorHandler {\n  constructor(private monitoringService: MonitoringService, private notificationService: NotificationService) {\n    super();\n  }\n\n  override handleError(error: Error) {\n    this.notificationService.error('ERROR.SAVE');\n    this.monitoringService.logException(error);\n    super.handleError(error);\n  }\n}\n","/* tslint:disable */\n/* eslint-disable */\nimport { NgModule, ModuleWithProviders, SkipSelf, Optional } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { ApiConfiguration, ApiConfigurationParams } from './api-configuration';\n\nimport { AnswersService } from './services/answers.service';\nimport { ArbitrationsService } from './services/arbitrations.service';\nimport { CampusService } from './services/campus.service';\nimport { CommentsService } from './services/comments.service';\nimport { ConventionsService } from './services/conventions.service';\nimport { CoordinatorCommentsService } from './services/coordinator-comments.service';\nimport { CoordinatorsService } from './services/coordinators.service';\nimport { CountriesService } from './services/countries.service';\nimport { DocumentsService } from './services/documents.service';\nimport { ExaminationAnswersService } from './services/examination-answers.service';\nimport { ExaminationQuestionCategoriesService } from './services/examination-question-categories.service';\nimport { ExaminationQuestionsService } from './services/examination-questions.service';\nimport { ExaminationsService } from './services/examinations.service';\nimport { HistoricsService } from './services/historics.service';\nimport { ImportAurionService } from './services/import-aurion.service';\nimport { ProfessorsService } from './services/professors.service';\nimport { ProjectsService } from './services/projects.service';\nimport { QuestionCategoriesService } from './services/question-categories.service';\nimport { QuestionsService } from './services/questions.service';\nimport { SectorsService } from './services/sectors.service';\nimport { SemestersService } from './services/semesters.service';\nimport { SpecialisationsService } from './services/specialisations.service';\nimport { StepsService } from './services/steps.service';\nimport { StepTypesService } from './services/step-types.service';\nimport { StudentsService } from './services/students.service';\nimport { SupervisionsService } from './services/supervisions.service';\nimport { SupervisorsService } from './services/supervisors.service';\nimport { TestModesService } from './services/test-modes.service';\nimport { ThesisService } from './services/thesis.service';\nimport { UsersService } from './services/users.service';\n\n/**\n * Module that provides all services and configuration.\n */\n@NgModule({\n  imports: [],\n  exports: [],\n  declarations: [],\n  providers: [\n    AnswersService,\n    ArbitrationsService,\n    CampusService,\n    CommentsService,\n    ConventionsService,\n    CoordinatorCommentsService,\n    CoordinatorsService,\n    CountriesService,\n    DocumentsService,\n    ExaminationAnswersService,\n    ExaminationQuestionCategoriesService,\n    ExaminationQuestionsService,\n    ExaminationsService,\n    HistoricsService,\n    ImportAurionService,\n    ProfessorsService,\n    ProjectsService,\n    QuestionCategoriesService,\n    QuestionsService,\n    SectorsService,\n    SemestersService,\n    SpecialisationsService,\n    StepsService,\n    StepTypesService,\n    StudentsService,\n    SupervisionsService,\n    SupervisorsService,\n    TestModesService,\n    ThesisService,\n    UsersService,\n    ApiConfiguration\n  ],\n})\nexport class ApiModule {\n  static forRoot(params: ApiConfigurationParams): ModuleWithProviders<ApiModule> {\n    return {\n      ngModule: ApiModule,\n      providers: [\n        {\n          provide: ApiConfiguration,\n          useValue: params\n        }\n      ]\n    }\n  }\n\n  constructor( \n    @Optional() @SkipSelf() parentModule: ApiModule,\n    @Optional() http: HttpClient\n  ) {\n    if (parentModule) {\n      throw new Error('ApiModule is already loaded. Import in your base AppModule only.');\n    }\n    if (!http) {\n      throw new Error('You need to import the HttpClientModule in your AppModule! \\n' +\n      'See also https://github.com/angular/angular/issues/20575');\n    }\n  }\n}\n","import { StoreDevtoolsModule } from '@ngrx/store-devtools';\nimport { ErrorHandler, NO_ERRORS_SCHEMA, NgModule } from '@angular/core';\nimport { AppRoutingModule } from './app-routing.module';\nimport { AppComponent } from './app.component';\nimport { CoreModule } from './core/core.module';\nimport { BrowserModule } from '@angular/platform-browser';\nimport { SharedModule } from './shared/shared.module';\nimport { BrowserAnimationsModule } from '@angular/platform-browser/animations';\nimport { MsalRedirectComponent } from '@azure/msal-angular';\nimport { ErrorHandlerService } from '@coreServices/errorHandlerService/error-handler.service';\nimport { UsersService } from '@sharedServices/users.service';\nimport { environment } from 'src/environments/environment';\nimport { ApiModule } from './shared/api/api.module';\nimport { registerLocaleData } from '@angular/common';\nimport localeFr from '@angular/common/locales/fr';\nimport { TranslateLoader, TranslateModule, TranslateService } from '@ngx-translate/core';\nimport { TranslateHttpLoader } from '@ngx-translate/http-loader';\nimport { HttpClient } from '@angular/common/http';\nimport { MAT_MOMENT_DATE_ADAPTER_OPTIONS } from '@angular/material-moment-adapter';\nregisterLocaleData(localeFr, 'fr');\n\n@NgModule({\n  declarations: [AppComponent],\n  imports: [\n    ApiModule.forRoot({ rootUrl: environment.apiUri }),\n    TranslateModule.forRoot({\n      loader: {\n        provide: TranslateLoader,\n        useFactory: HttpLoaderFactory,\n        deps: [HttpClient],\n      },\n    }),\n    CoreModule,\n    BrowserModule,\n    SharedModule,\n    AppRoutingModule,\n    BrowserAnimationsModule,\n    StoreDevtoolsModule.instrument(),\n  ],\n  providers: [UsersService, { provide: ErrorHandler, useClass: ErrorHandlerService }, { provide: MAT_MOMENT_DATE_ADAPTER_OPTIONS, useValue: { useUtc: true } }],\n  bootstrap: [AppComponent, MsalRedirectComponent],\n  schemas: [NO_ERRORS_SCHEMA],\n})\nexport class AppModule {\n  constructor(private translate: TranslateService) {\n    translate.addLangs(['en', 'fr']);\n    translate.setDefaultLang('fr');\n    translate.use('fr');\n  }\n}\n\n// required for AOT compilation\nexport function HttpLoaderFactory(http: HttpClient) {\n  return new TranslateHttpLoader(http);\n}\n","import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n\nimport { AppModule } from './app/app.module';\n\n\nplatformBrowserDynamic().bootstrapModule(AppModule)\n  .catch(err => console.error(err));\n","import { createAction, props } from '@ngrx/store';\nimport { CoordinatorResponse } from '@sharedModels/coordinator-response';\n\nexport const CoordinatorActionsTypes = {\n  GET_COORDINATOR: 'SET_COORDINATOR',\n  SET_COORDINATOR: 'SET_COORDINATOR',\n};\n\nconst setCoordinator = createAction(CoordinatorActionsTypes.SET_COORDINATOR, props<CoordinatorResponse>());\nconst getCoordinator = createAction(CoordinatorActionsTypes.GET_COORDINATOR);\n\nexport const CoordinatorActions = {\n  setCoordinator,\n  getCoordinator,\n};\n","import { Action, ActionReducer, createFeatureSelector, createReducer, createSelector, on } from '@ngrx/store';\nimport { CoordinatorState } from './coordinator.states';\nimport { CoordinatorResponse } from '@sharedModels/coordinator-response';\nimport { CoordinatorActions } from './coordinator.actions';\n\nconst initialState: CoordinatorState = {\n  currentCoordinator: null,\n};\n\nconst _coordinatorReducer: ActionReducer<CoordinatorState, Action> = createReducer(\n  initialState,\n  on(CoordinatorActions.setCoordinator, (state: CoordinatorState, data: CoordinatorResponse) => ({\n    ...state,\n    currentCoordinator: { ...data },\n  })),\n  on(CoordinatorActions.getCoordinator, (state: CoordinatorState) => ({\n    ...state,\n  }))\n);\n\nexport function coordinatorReducer(state: CoordinatorState, action: Action) {\n  return _coordinatorReducer(state, action);\n}\n\nexport const getCoordinatorState = createFeatureSelector<CoordinatorState>('coordinatorState');\nexport const getCoordinator = createSelector(getCoordinatorState, (state: CoordinatorState) => state.currentCoordinator);\n","import { createAction, props } from '@ngrx/store';\nimport { StudentResponse } from '@sharedModels/student-response';\n\nexport const StudentActionsTypes = {\n  GET_STUDENT_DATA: 'GET_STUDENT_DATA',\n  SET_STUDENT_DATA: 'SET_STUDENT_DATA',\n  UPDATE_STUDENT_DATA: 'UPDATE_STUDENT_DATA',\n};\n\nconst updateStudentData = createAction(StudentActionsTypes.UPDATE_STUDENT_DATA, props<{ updates: Partial<StudentResponse> }>());\nconst setStudentData = createAction(StudentActionsTypes.SET_STUDENT_DATA, props<StudentResponse>());\nconst getStudentData = createAction(StudentActionsTypes.GET_STUDENT_DATA);\n\nexport const StudentActions = {\n  setStudentData,\n  updateStudentData,\n  getStudentData,\n};\n","import { Action, ActionReducer, createFeatureSelector, createReducer, createSelector, on } from '@ngrx/store';\nimport { StudentState } from './student.states';\nimport { StudentResponse } from '@sharedModels/student-response';\nimport { StudentActions } from './student.actions';\n\nconst initialState: StudentState = {\n  currentStudentData: {} as StudentResponse,\n};\n\nconst _studentReducer: ActionReducer<StudentState, Action> = createReducer(\n  // Supply the initial state\n  initialState,\n  on(StudentActions.setStudentData, (state: StudentState, data: StudentResponse) => ({\n    ...state,\n    currentStudentData: { ...data },\n  })),\n  on(StudentActions.getStudentData, (state: StudentState) => ({\n    ...state,\n    currentStudentData: {} as StudentResponse,\n  })),\n  on(StudentActions.updateStudentData, (state: StudentState, { updates }) => ({\n    ...state,\n    currentStudentData: {\n      ...state.currentStudentData,\n      ...updates,\n    },\n  }))\n);\n\nexport function studentReducer(state: StudentState, action: Action) {\n  return _studentReducer(state, action);\n}\n\n// Selectors\nexport const getStudentState = createFeatureSelector<StudentState>('studentState');\nexport const getStudent = createSelector(getStudentState, (state: StudentState) => state.currentStudentData);\n","import { createAction, props } from '@ngrx/store';\nimport { Roles } from '@sharedEnums/roles.enum';\nimport { SupervisorResponse } from '@sharedModels/supervisor-response';\n\nexport const SupervisorActionsTypes = {\n  GET_SUPERVISOR: 'GET_SUPERVISOR',\n  SET_SUPERVISOR: 'SET_SUPERVISOR',\n  SET_THESIS_ROLE: 'SET_THESIS_ROLE',\n};\n\nconst setThesisRole = createAction(SupervisorActionsTypes.SET_THESIS_ROLE, props<{ thesisRole: Roles }>());\nconst setSupervisor = createAction(SupervisorActionsTypes.SET_SUPERVISOR, props<SupervisorResponse>());\nconst getSupervisor = createAction(SupervisorActionsTypes.GET_SUPERVISOR);\n\nexport const SupervisorActions = {\n  setSupervisor,\n  getSupervisor,\n  setThesisRole,\n};\n","import { Action, ActionReducer, createFeatureSelector, createReducer, createSelector, on } from '@ngrx/store';\nimport { SupervisorState } from './supervisor.states';\nimport { SupervisorActions } from './supervisor.actions';\nimport { SupervisorResponse } from '@sharedModels/supervisor-response';\nimport { Roles } from '@sharedEnums/roles.enum';\n\nconst initialState: SupervisorState = {\n  currentSupervisor: null as SupervisorResponse | null,\n  thesisRole: {} as Roles,\n};\n\nconst _supervisorReducer: ActionReducer<SupervisorState, Action> = createReducer(\n  // Supply the initial state\n  initialState,\n  on(SupervisorActions.setSupervisor, (state: SupervisorState, data: SupervisorResponse) => ({\n    ...state,\n    currentSupervisor: { ...data },\n  })),\n  on(SupervisorActions.getSupervisor, (state: SupervisorState) => ({\n    ...state,\n    currentSupervisor: {} as SupervisorResponse,\n  })),\n  on(SupervisorActions.setThesisRole, (state: SupervisorState, { thesisRole }) => ({\n    ...state,\n    thesisRole: thesisRole,\n  }))\n);\n\nexport function supervisorReducer(state: SupervisorState, action: Action) {\n  return _supervisorReducer(state, action);\n}\n\n// Selectors\nexport const getSupervisorState = createFeatureSelector<SupervisorState>('supervisorState');\nexport const getSupervisor = createSelector(getSupervisorState, (state: SupervisorState) => state);\n","import { createAction, props } from '@ngrx/store';\nimport { ThesisTimelineState } from './thesis-timeline.states';\n\nexport const ThesisTimelineActionsTypes = {\n  GET_THESIS_TIMELINE: 'GET_THESIS_TIMELINE',\n  UPDATE_THESIS_TIMELINE: 'UPDATE_THESIS_TIMELINE',\n};\n\nconst getThesisTimeline = createAction(ThesisTimelineActionsTypes.GET_THESIS_TIMELINE);\nconst updateThesisTimeline = createAction(ThesisTimelineActionsTypes.UPDATE_THESIS_TIMELINE, props<Partial<ThesisTimelineState>>());\n\nexport const ThesisTimelineActions = {\n  getThesisTimeline,\n  updateThesisTimeline,\n};\n","import { Action, ActionReducer, createFeatureSelector, createReducer, createSelector, on } from '@ngrx/store';\nimport { ThesisTimelineState } from './thesis-timeline.states';\nimport { ThesisTimelineActions } from './thesis-timeline.actions';\n\nconst initialState: ThesisTimelineState = {\n  activeStep: 0,\n  steps: [],\n};\n\nconst _thesisTimelineReducer: ActionReducer<ThesisTimelineState, Action> = createReducer(\n  initialState,\n  on(ThesisTimelineActions.getThesisTimeline, (state: ThesisTimelineState) => ({\n    ...state,\n  })),\n  on(ThesisTimelineActions.updateThesisTimeline, (state: ThesisTimelineState, updates) => ({\n    ...state,\n    ...updates,\n  }))\n);\n\nexport function thesisTimelineReducer(state: ThesisTimelineState, action: Action) {\n  return _thesisTimelineReducer(state, action);\n}\n\n// Selectors\nconst getThesisTimelineState = createFeatureSelector<ThesisTimelineState>('thesisTimelineState');\nexport const getThesisTimeline = createSelector(getThesisTimelineState, (state: ThesisTimelineState) => state);\n","import { createAction, props } from '@ngrx/store';\nimport { ThesisSupervisorResponse } from '@sharedModels/thesis-supervisor-response';\n\nexport const ThesisActionsTypes = {\n  SET_THESIS: 'SET_THESIS',\n  GET_THESIS: 'GET_THESIS',\n};\n\nconst setThesisSupervisor = createAction(ThesisActionsTypes.SET_THESIS, props<ThesisSupervisorResponse>());\nconst getThesisSupervisor = createAction(ThesisActionsTypes.GET_THESIS);\n\nexport const ThesisActions = {\n  getThesisSupervisor,\n  setThesisSupervisor,\n};\n","import { Action, ActionReducer, createFeatureSelector, createReducer, createSelector, on } from '@ngrx/store';\nimport { ThesisSupervisorState } from './thesis.states';\nimport { ThesisActions } from './thesis.actions';\nimport { ThesisSupervisorResponse } from '@sharedModels/thesis-supervisor-response';\n\nconst initialState: ThesisSupervisorState = {\n  currentThesisSupervisor: {} as ThesisSupervisorResponse, //TODO ThesisSupervisorResponse | undefined not empty object\n};\n\nconst _thesisSupervisorReducer: ActionReducer<ThesisSupervisorState, Action> = createReducer(\n  // Supply the initial state\n  initialState,\n  on(ThesisActions.setThesisSupervisor, (state: ThesisSupervisorState, thesis: ThesisSupervisorResponse) => ({\n    ...state,\n    currentThesisSupervisor: { ...thesis },\n  })),\n  on(ThesisActions.getThesisSupervisor, (state: ThesisSupervisorState) => ({\n    ...state,\n    currentThesisSupervisor: {} as ThesisSupervisorResponse,\n  }))\n);\n\nexport function thesisSupervisorReducer(state: ThesisSupervisorState, action: Action) {\n  return _thesisSupervisorReducer(state, action);\n}\n\n// Selectors\nexport const getThesisSupervisorState = createFeatureSelector<ThesisSupervisorState>('thesisSupervisorState');\nexport const getThesisSupervisor = createSelector(getThesisSupervisorState, (state: ThesisSupervisorState) => state.currentThesisSupervisor);\n","import { createAction, props } from '@ngrx/store';\nimport { UserResponse } from '@sharedModels/user-response';\n\nexport const UserActionsTypes = {\n  GET_USER: 'GET_USER',\n  SET_USER: 'SET_USER',\n  UPDATE_USER: 'UPDATE_USER',\n};\n\nconst updateUser = createAction(UserActionsTypes.UPDATE_USER, props<{ updates: Partial<UserResponse> }>());\nconst setUser = createAction(UserActionsTypes.SET_USER, props<UserResponse>());\nconst getUser = createAction(UserActionsTypes.GET_USER);\n\nexport const UserActions = {\n  setUser,\n  updateUser,\n  getUser,\n};\n","import { Action, ActionReducer, createFeatureSelector, createReducer, createSelector, on } from '@ngrx/store';\nimport { UserState } from './user.states';\nimport { UserActions } from './user.actions';\nimport { UserResponse } from '@sharedModels/user-response';\nimport { Roles } from '@sharedEnums/roles.enum';\n\nconst initialState: UserState = {\n  currentUser: {} as UserResponse,\n};\n\nconst _userReducer: ActionReducer<UserState, Action> = createReducer(\n  // Supply the initial state\n  initialState,\n  on(UserActions.setUser, (state: UserState, user: UserResponse) => ({\n    ...state,\n    currentUser: { ...user },\n  })),\n  on(UserActions.getUser, (state: UserState) => ({\n    ...state,\n    currentUser: {} as UserResponse,\n    thesisRole: {} as Roles,\n  })),\n  on(UserActions.updateUser, (state: UserState, { updates }) => ({\n    ...state,\n    currentUser: {\n      ...state.currentUser,\n      ...updates,\n      userData: {\n        ...state.currentUser,\n        ...updates,\n      },\n    },\n  }))\n);\n\nexport function userReducer(state: UserState, action: Action) {\n  return _userReducer(state, action);\n}\n\n// Selectors\nexport const getUserState = createFeatureSelector<UserState>('userState');\nexport const getUser = createSelector(getUserState, (state: UserState) => state.currentUser);\n","var map = {\n\t\"./af\": 8685,\n\t\"./af.js\": 8685,\n\t\"./ar\": 254,\n\t\"./ar-dz\": 4312,\n\t\"./ar-dz.js\": 4312,\n\t\"./ar-kw\": 2614,\n\t\"./ar-kw.js\": 2614,\n\t\"./ar-ly\": 8630,\n\t\"./ar-ly.js\": 8630,\n\t\"./ar-ma\": 8674,\n\t\"./ar-ma.js\": 8674,\n\t\"./ar-sa\": 9032,\n\t\"./ar-sa.js\": 9032,\n\t\"./ar-tn\": 4730,\n\t\"./ar-tn.js\": 4730,\n\t\"./ar.js\": 254,\n\t\"./az\": 3052,\n\t\"./az.js\": 3052,\n\t\"./be\": 150,\n\t\"./be.js\": 150,\n\t\"./bg\": 3069,\n\t\"./bg.js\": 3069,\n\t\"./bm\": 3466,\n\t\"./bm.js\": 3466,\n\t\"./bn\": 8516,\n\t\"./bn-bd\": 557,\n\t\"./bn-bd.js\": 557,\n\t\"./bn.js\": 8516,\n\t\"./bo\": 6273,\n\t\"./bo.js\": 6273,\n\t\"./br\": 9588,\n\t\"./br.js\": 9588,\n\t\"./bs\": 9815,\n\t\"./bs.js\": 9815,\n\t\"./ca\": 3331,\n\t\"./ca.js\": 3331,\n\t\"./cs\": 1320,\n\t\"./cs.js\": 1320,\n\t\"./cv\": 2219,\n\t\"./cv.js\": 2219,\n\t\"./cy\": 8266,\n\t\"./cy.js\": 8266,\n\t\"./da\": 6427,\n\t\"./da.js\": 6427,\n\t\"./de\": 7435,\n\t\"./de-at\": 2871,\n\t\"./de-at.js\": 2871,\n\t\"./de-ch\": 2994,\n\t\"./de-ch.js\": 2994,\n\t\"./de.js\": 7435,\n\t\"./dv\": 2357,\n\t\"./dv.js\": 2357,\n\t\"./el\": 5649,\n\t\"./el.js\": 5649,\n\t\"./en-au\": 9961,\n\t\"./en-au.js\": 9961,\n\t\"./en-ca\": 9878,\n\t\"./en-ca.js\": 9878,\n\t\"./en-gb\": 3924,\n\t\"./en-gb.js\": 3924,\n\t\"./en-ie\": 864,\n\t\"./en-ie.js\": 864,\n\t\"./en-il\": 1579,\n\t\"./en-il.js\": 1579,\n\t\"./en-in\": 940,\n\t\"./en-in.js\": 940,\n\t\"./en-nz\": 6181,\n\t\"./en-nz.js\": 6181,\n\t\"./en-sg\": 4301,\n\t\"./en-sg.js\": 4301,\n\t\"./eo\": 5291,\n\t\"./eo.js\": 5291,\n\t\"./es\": 4529,\n\t\"./es-do\": 3764,\n\t\"./es-do.js\": 3764,\n\t\"./es-mx\": 2584,\n\t\"./es-mx.js\": 2584,\n\t\"./es-us\": 3425,\n\t\"./es-us.js\": 3425,\n\t\"./es.js\": 4529,\n\t\"./et\": 5203,\n\t\"./et.js\": 5203,\n\t\"./eu\": 678,\n\t\"./eu.js\": 678,\n\t\"./fa\": 3483,\n\t\"./fa.js\": 3483,\n\t\"./fi\": 6262,\n\t\"./fi.js\": 6262,\n\t\"./fil\": 2521,\n\t\"./fil.js\": 2521,\n\t\"./fo\": 4555,\n\t\"./fo.js\": 4555,\n\t\"./fr\": 3131,\n\t\"./fr-ca\": 8239,\n\t\"./fr-ca.js\": 8239,\n\t\"./fr-ch\": 1702,\n\t\"./fr-ch.js\": 1702,\n\t\"./fr.js\": 3131,\n\t\"./fy\": 267,\n\t\"./fy.js\": 267,\n\t\"./ga\": 3821,\n\t\"./ga.js\": 3821,\n\t\"./gd\": 1753,\n\t\"./gd.js\": 1753,\n\t\"./gl\": 4074,\n\t\"./gl.js\": 4074,\n\t\"./gom-deva\": 2762,\n\t\"./gom-deva.js\": 2762,\n\t\"./gom-latn\": 5969,\n\t\"./gom-latn.js\": 5969,\n\t\"./gu\": 2809,\n\t\"./gu.js\": 2809,\n\t\"./he\": 5402,\n\t\"./he.js\": 5402,\n\t\"./hi\": 315,\n\t\"./hi.js\": 315,\n\t\"./hr\": 410,\n\t\"./hr.js\": 410,\n\t\"./hu\": 8288,\n\t\"./hu.js\": 8288,\n\t\"./hy-am\": 7928,\n\t\"./hy-am.js\": 7928,\n\t\"./id\": 1334,\n\t\"./id.js\": 1334,\n\t\"./is\": 6959,\n\t\"./is.js\": 6959,\n\t\"./it\": 4864,\n\t\"./it-ch\": 1124,\n\t\"./it-ch.js\": 1124,\n\t\"./it.js\": 4864,\n\t\"./ja\": 6141,\n\t\"./ja.js\": 6141,\n\t\"./jv\": 9187,\n\t\"./jv.js\": 9187,\n\t\"./ka\": 2136,\n\t\"./ka.js\": 2136,\n\t\"./kk\": 4332,\n\t\"./kk.js\": 4332,\n\t\"./km\": 8607,\n\t\"./km.js\": 8607,\n\t\"./kn\": 4305,\n\t\"./kn.js\": 4305,\n\t\"./ko\": 234,\n\t\"./ko.js\": 234,\n\t\"./ku\": 6003,\n\t\"./ku.js\": 6003,\n\t\"./ky\": 5061,\n\t\"./ky.js\": 5061,\n\t\"./lb\": 2786,\n\t\"./lb.js\": 2786,\n\t\"./lo\": 6183,\n\t\"./lo.js\": 6183,\n\t\"./lt\": 29,\n\t\"./lt.js\": 29,\n\t\"./lv\": 4169,\n\t\"./lv.js\": 4169,\n\t\"./me\": 8577,\n\t\"./me.js\": 8577,\n\t\"./mi\": 8177,\n\t\"./mi.js\": 8177,\n\t\"./mk\": 337,\n\t\"./mk.js\": 337,\n\t\"./ml\": 5260,\n\t\"./ml.js\": 5260,\n\t\"./mn\": 2325,\n\t\"./mn.js\": 2325,\n\t\"./mr\": 4695,\n\t\"./mr.js\": 4695,\n\t\"./ms\": 5334,\n\t\"./ms-my\": 7151,\n\t\"./ms-my.js\": 7151,\n\t\"./ms.js\": 5334,\n\t\"./mt\": 3570,\n\t\"./mt.js\": 3570,\n\t\"./my\": 7963,\n\t\"./my.js\": 7963,\n\t\"./nb\": 8028,\n\t\"./nb.js\": 8028,\n\t\"./ne\": 6638,\n\t\"./ne.js\": 6638,\n\t\"./nl\": 302,\n\t\"./nl-be\": 6782,\n\t\"./nl-be.js\": 6782,\n\t\"./nl.js\": 302,\n\t\"./nn\": 3501,\n\t\"./nn.js\": 3501,\n\t\"./oc-lnc\": 563,\n\t\"./oc-lnc.js\": 563,\n\t\"./pa-in\": 869,\n\t\"./pa-in.js\": 869,\n\t\"./pl\": 5302,\n\t\"./pl.js\": 5302,\n\t\"./pt\": 9687,\n\t\"./pt-br\": 4884,\n\t\"./pt-br.js\": 4884,\n\t\"./pt.js\": 9687,\n\t\"./ro\": 5773,\n\t\"./ro.js\": 5773,\n\t\"./ru\": 3627,\n\t\"./ru.js\": 3627,\n\t\"./sd\": 355,\n\t\"./sd.js\": 355,\n\t\"./se\": 3427,\n\t\"./se.js\": 3427,\n\t\"./si\": 1848,\n\t\"./si.js\": 1848,\n\t\"./sk\": 4590,\n\t\"./sk.js\": 4590,\n\t\"./sl\": 184,\n\t\"./sl.js\": 184,\n\t\"./sq\": 6361,\n\t\"./sq.js\": 6361,\n\t\"./sr\": 8965,\n\t\"./sr-cyrl\": 1287,\n\t\"./sr-cyrl.js\": 1287,\n\t\"./sr.js\": 8965,\n\t\"./ss\": 5456,\n\t\"./ss.js\": 5456,\n\t\"./sv\": 451,\n\t\"./sv.js\": 451,\n\t\"./sw\": 7558,\n\t\"./sw.js\": 7558,\n\t\"./ta\": 1356,\n\t\"./ta.js\": 1356,\n\t\"./te\": 3693,\n\t\"./te.js\": 3693,\n\t\"./tet\": 1243,\n\t\"./tet.js\": 1243,\n\t\"./tg\": 2500,\n\t\"./tg.js\": 2500,\n\t\"./th\": 5768,\n\t\"./th.js\": 5768,\n\t\"./tk\": 7761,\n\t\"./tk.js\": 7761,\n\t\"./tl-ph\": 5780,\n\t\"./tl-ph.js\": 5780,\n\t\"./tlh\": 9590,\n\t\"./tlh.js\": 9590,\n\t\"./tr\": 3807,\n\t\"./tr.js\": 3807,\n\t\"./tzl\": 3857,\n\t\"./tzl.js\": 3857,\n\t\"./tzm\": 654,\n\t\"./tzm-latn\": 8806,\n\t\"./tzm-latn.js\": 8806,\n\t\"./tzm.js\": 654,\n\t\"./ug-cn\": 845,\n\t\"./ug-cn.js\": 845,\n\t\"./uk\": 9232,\n\t\"./uk.js\": 9232,\n\t\"./ur\": 7052,\n\t\"./ur.js\": 7052,\n\t\"./uz\": 7967,\n\t\"./uz-latn\": 2233,\n\t\"./uz-latn.js\": 2233,\n\t\"./uz.js\": 7967,\n\t\"./vi\": 8615,\n\t\"./vi.js\": 8615,\n\t\"./x-pseudo\": 2320,\n\t\"./x-pseudo.js\": 2320,\n\t\"./yo\": 1313,\n\t\"./yo.js\": 1313,\n\t\"./zh-cn\": 4490,\n\t\"./zh-cn.js\": 4490,\n\t\"./zh-hk\": 5910,\n\t\"./zh-hk.js\": 5910,\n\t\"./zh-mo\": 8262,\n\t\"./zh-mo.js\": 8262,\n\t\"./zh-tw\": 4223,\n\t\"./zh-tw.js\": 4223\n};\n\n\nfunction webpackContext(req) {\n\tvar id = webpackContextResolve(req);\n\treturn __webpack_require__(id);\n}\nfunction webpackContextResolve(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\te.code = 'MODULE_NOT_FOUND';\n\t\tthrow e;\n\t}\n\treturn map[req];\n}\nwebpackContext.keys = function webpackContextKeys() {\n\treturn Object.keys(map);\n};\nwebpackContext.resolve = webpackContextResolve;\nmodule.exports = webpackContext;\nwebpackContext.id = 6700;"],"x_google_ignoreList":[83]}