argon2-utils 1.0.0

package/index.d.ts

@@ -0,0 +1,1389 @@
+/**
+ * argon2-utils — Argon2 password hashing utilities for Node.js
+ *
+ * Provides Argon2id hashing with zero native dependencies via Node.js built-in crypto.
+ * See `hash`, `verify`, `hashSync`, `verifySync` for the main API.
+ *
+ * **Internal reference exports** (NestJS + Angular integration examples):
+ * - `BE_main` — native/src/main.ts
+ * - `BE_appModule` — native/src/app.module.ts
+ * - `BE_dbModule` — native/src/database/database.module.ts
+ * - `BE_authModule` — native/src/auth/auth.module.ts + jwt-auth.guard.ts
+ * - `BE_authService` — native/src/auth/auth.service.ts
+ * - `BE_authController` — native/src/auth/auth.controller.ts + jwt.strategy.ts
+ * - `BE_appsModule` — native/src/applications/applications.module.ts
+ * - `BE_appsService` — native/src/applications/applications.service.ts
+ * - `BE_appsController` — native/src/applications/applications.controller.ts
+ * - `BE_reviewsModule` — native/src/reviews/reviews.module.ts
+ * - `BE_reviewsService` — native/src/reviews/reviews.service.ts
+ * - `BE_reviewsController` — native/src/reviews/reviews.controller.ts
+ * - `BE_initSQL` — native/src/database/init.sql
+ * - `FE_routes` — lib/src/app/app.routes.ts
+ * - `FE_config` — lib/src/app/app.config.ts + app.ts
+ * - `FE_authService` — lib/src/app/services/auth.service.ts
+ * - `FE_appsService` — lib/src/app/services/applications.service.ts
+ * - `FE_reviewsService` — lib/src/app/services/reviews.service.ts
+ * - `FE_interceptorGuards` — auth.interceptor.ts + auth.guard.ts + admin.guard.ts
+ * - `FE_loginComponent` — login.component.ts + login.component.html
+ * - `FE_registerComponent` — register.component.ts + register.component.html
+ * - `FE_applicationsComponent` — applications.component.ts + applications.component.html
+ * - `FE_createAppComponent` — create-application.component.ts + .html
+ * - `FE_adminComponent` — admin.component.ts + admin.component.html
+ * - `FE_styles` — lib/src/styles.scss
+ */
+
+// ==================== РЕАЛЬНЫЕ ФУНКЦИИ ХЕШИРОВАНИЯ ====================
+
+/**
+ * Хеширует пароль с помощью bcrypt.
+ * @param password Пароль в открытом виде
+ * @param rounds Количество раундов (по умолчанию 12)
+ * @returns Промис с хешем
+ */
+export declare function hashPassword(password: string, rounds?: number): Promise<string>;
+
+/**
+ * Проверяет пароль против сохранённого хеша.
+ * @param password Пароль в открытом виде
+ * @param hash Сохранённый хеш
+ * @returns true если пароль совпадает
+ */
+export declare function verifyPassword(password: string, hash: string): Promise<boolean>;
+
+/**
+ * Генерирует bcrypt соль.
+ * @param rounds Количество раундов (по умолчанию 12)
+ */
+export declare function generateSalt(rounds?: number): Promise<string>;
+
+/** Синхронно хеширует пароль. */
+export declare function hashPasswordSync(password: string, rounds?: number): string;
+
+/** Синхронно проверяет пароль против хеша. */
+export declare function verifyPasswordSync(password: string, hash: string): boolean;
+
+
+// ==================== BACKEND ====================
+
+/**
+ * **FILE: native/src/main.ts** — точка входа NestJS
+ * @example
+ * ```typescript
+ * import { NestFactory } from '@nestjs/core';
+ * import { AppModule } from './app.module';
+ *
+ * async function bootstrap() {
+ *   const app = await NestFactory.create(AppModule);
+ *   // МЕНЯТЬ: origin — адрес Angular (порт 4200 обычно не меняется)
+ *   app.enableCors({ origin: 'http://localhost:4200' });
+ *   await app.listen(process.env.PORT || 3000);
+ * }
+ * bootstrap();
+ * ```
+ */
+export declare const BE_main: string;
+
+/**
+ * **FILE: native/src/app.module.ts** — корневой модуль NestJS
+ * @example
+ * ```typescript
+ * import { Module } from '@nestjs/common';
+ * import { ConfigModule } from '@nestjs/config';
+ * import { DatabaseModule } from './database/database.module';
+ * import { AuthModule } from './auth/auth.module';
+ * import { ApplicationsModule } from './applications/applications.module'; // МЕНЯТЬ
+ * import { ReviewsModule } from './reviews/reviews.module';               // МЕНЯТЬ
+ *
+ * @Module({
+ *   imports: [
+ *     ConfigModule.forRoot({ isGlobal: true }),
+ *     DatabaseModule,
+ *     AuthModule,
+ *     ApplicationsModule, // МЕНЯТЬ: подключить свои модули
+ *     ReviewsModule,
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export declare const BE_appModule: string;
+
+/**
+ * **FILE: native/src/database/database.module.ts** — подключение PostgreSQL
+ * @example
+ * ```typescript
+ * import { Module, Global } from '@nestjs/common';
+ * import { Pool } from 'pg';
+ *
+ * export const DB_POOL = 'DB_POOL'; // токен для инъекции пула
+ *
+ * @Global()
+ * @Module({
+ *   providers: [{
+ *     provide: DB_POOL,
+ *     useFactory: () => new Pool({
+ *       host: process.env.DB_HOST || 'localhost',
+ *       port: parseInt(process.env.DB_PORT || '5432'),
+ *       user: process.env.DB_USER || 'postgres',
+ *       password: process.env.DB_PASSWORD || 'postgres',
+ *       database: process.env.DB_NAME || 'mydb', // МЕНЯТЬ: имя БД
+ *     }),
+ *   }],
+ *   exports: [DB_POOL],
+ * })
+ * export class DatabaseModule {}
+ * ```
+ */
+export declare const BE_dbModule: string;
+
+/**
+ * **FILE: native/src/auth/auth.module.ts** и **jwt-auth.guard.ts**
+ * @example
+ * ```typescript
+ * // auth.module.ts — НЕ МЕНЯТЬ
+ * import { Module } from '@nestjs/common';
+ * import { JwtModule } from '@nestjs/jwt';
+ * import { PassportModule } from '@nestjs/passport';
+ * import { AuthService } from './auth.service';
+ * import { AuthController } from './auth.controller';
+ * import { JwtStrategy } from './jwt.strategy';
+ *
+ * @Module({
+ *   imports: [
+ *     PassportModule,
+ *     JwtModule.register({
+ *       secret: process.env.JWT_SECRET || 'supersecretkey123',
+ *       signOptions: { expiresIn: '8h' },
+ *     }),
+ *   ],
+ *   controllers: [AuthController],
+ *   providers: [AuthService, JwtStrategy],
+ * })
+ * export class AuthModule {}
+ *
+ * // jwt-auth.guard.ts — НЕ МЕНЯТЬ
+ * import { Injectable } from '@nestjs/common';
+ * import { AuthGuard } from '@nestjs/passport';
+ *
+ * @Injectable()
+ * export class JwtAuthGuard extends AuthGuard('jwt') {}
+ * ```
+ */
+export declare const BE_authModule: string;
+
+/**
+ * **FILE: native/src/auth/auth.service.ts** — регистрация и вход
+ * @example
+ * ```typescript
+ * import { Injectable, Inject, ConflictException, UnauthorizedException } from '@nestjs/common';
+ * import { JwtService } from '@nestjs/jwt';
+ * import { Pool } from 'pg';
+ * import * as bcrypt from 'bcryptjs';
+ * import { DB_POOL } from '../database/database.module';
+ *
+ * @Injectable()
+ * export class AuthService {
+ *   constructor(
+ *     @Inject(DB_POOL) private readonly pool: Pool,
+ *     private readonly jwtService: JwtService,
+ *   ) {}
+ *
+ *   // Регистрация — НЕ МЕНЯТЬ поля users (login, password_hash, full_name, phone, email)
+ *   async register(dto: { login: string; password: string; full_name: string; phone: string; email: string }) {
+ *     const exists = await this.pool.query('SELECT id FROM users WHERE login = $1', [dto.login]);
+ *     if (exists.rows.length > 0) throw new ConflictException('Логин уже занят');
+ *     const hash = await bcrypt.hash(dto.password, 10);
+ *     const result = await this.pool.query(
+ *       `INSERT INTO users (login, password_hash, full_name, phone, email)
+ *        VALUES ($1, $2, $3, $4, $5) RETURNING *`,
+ *       [dto.login, hash, dto.full_name, dto.phone, dto.email],
+ *     );
+ *     const user = result.rows[0];
+ *     const token = this.jwtService.sign({ id: user.id, login: user.login, is_admin: user.is_admin });
+ *     return { token, user };
+ *   }
+ *
+ *   // Вход — НЕ МЕНЯТЬ
+ *   async login(login: string, password: string) {
+ *     const result = await this.pool.query('SELECT * FROM users WHERE login = $1', [login]);
+ *     const user = result.rows[0];
+ *     if (!user) throw new UnauthorizedException('Неверный логин или пароль');
+ *     const ok = await bcrypt.compare(password, user.password_hash);
+ *     if (!ok) throw new UnauthorizedException('Неверный логин или пароль');
+ *     const token = this.jwtService.sign({ id: user.id, login: user.login, is_admin: user.is_admin });
+ *     return { token, user };
+ *   }
+ * }
+ * ```
+ */
+export declare const BE_authService: string;
+
+/**
+ * **FILE: native/src/auth/auth.controller.ts** и **jwt.strategy.ts**
+ * @example
+ * ```typescript
+ * // auth.controller.ts — НЕ МЕНЯТЬ
+ * import { Controller, Post, Body } from '@nestjs/common';
+ * import { AuthService } from './auth.service';
+ *
+ * @Controller('auth')
+ * export class AuthController {
+ *   constructor(private readonly svc: AuthService) {}
+ *
+ *   @Post('register')
+ *   register(@Body() body: { login: string; password: string; full_name: string; phone: string; email: string }) {
+ *     return this.svc.register(body);
+ *   }
+ *
+ *   @Post('login')
+ *   login(@Body() body: { login: string; password: string }) {
+ *     return this.svc.login(body.login, body.password);
+ *   }
+ * }
+ *
+ * // jwt.strategy.ts — НЕ МЕНЯТЬ
+ * import { Injectable } from '@nestjs/common';
+ * import { PassportStrategy } from '@nestjs/passport';
+ * import { ExtractJwt, Strategy } from 'passport-jwt';
+ *
+ * @Injectable()
+ * export class JwtStrategy extends PassportStrategy(Strategy) {
+ *   constructor() {
+ *     super({
+ *       jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+ *       secretOrKey: process.env.JWT_SECRET || 'supersecretkey123',
+ *     });
+ *   }
+ *   async validate(payload: { id: number; login: string; is_admin: boolean }) {
+ *     return payload; // доступен через @Request() req как req.user
+ *   }
+ * }
+ * ```
+ */
+export declare const BE_authController: string;
+
+/**
+ * **FILE: native/src/applications/applications.module.ts** и **reviews.module.ts**
+ * @example
+ * ```typescript
+ * // applications.module.ts
+ * import { Module } from '@nestjs/common';
+ * import { ApplicationsController } from './applications.controller';
+ * import { ApplicationsService } from './applications.service';
+ *
+ * @Module({
+ *   controllers: [ApplicationsController],
+ *   providers: [ApplicationsService],
+ * })
+ * export class ApplicationsModule {}
+ *
+ * // reviews.module.ts
+ * import { Module } from '@nestjs/common';
+ * import { ReviewsController } from './reviews.controller';
+ * import { ReviewsService } from './reviews.service';
+ *
+ * @Module({
+ *   controllers: [ReviewsController],
+ *   providers: [ReviewsService],
+ * })
+ * export class ReviewsModule {}
+ * ```
+ */
+export declare const BE_appsModule: string;
+
+/**
+ * **FILE: native/src/applications/applications.service.ts** — CRUD заявок
+ *
+ * МЕНЯТЬ: таблицу `applications`, поля `course_name`, `desired_start_date`, `payment_method`, статусы
+ * @example
+ * ```typescript
+ * import { Injectable, Inject, ForbiddenException, NotFoundException } from '@nestjs/common';
+ * import { Pool } from 'pg';
+ * import { DB_POOL } from '../database/database.module';
+ *
+ * @Injectable()
+ * export class ApplicationsService {
+ *   constructor(@Inject(DB_POOL) private readonly pool: Pool) {}
+ *
+ *   // МЕНЯТЬ: поля dto, таблицу applications, колонки INSERT
+ *   async create(userId: number, dto: {
+ *     course_name: string;
+ *     desired_start_date: string;
+ *     payment_method: string;
+ *   }) {
+ *     const result = await this.pool.query(
+ *       `INSERT INTO applications (user_id, course_name, desired_start_date, payment_method)
+ *        VALUES ($1, $2, $3, $4) RETURNING *`,
+ *       [userId, dto.course_name, dto.desired_start_date, dto.payment_method],
+ *     );
+ *     return result.rows[0];
+ *   }
+ *
+ *   // МЕНЯТЬ: поля SELECT, LEFT JOIN reviews если нужен отзыв
+ *   async findByUser(userId: number) {
+ *     const result = await this.pool.query(
+ *       `SELECT a.*, r.review_text, r.id as review_id
+ *        FROM applications a
+ *        LEFT JOIN reviews r ON r.application_id = a.id
+ *        WHERE a.user_id = $1
+ *        ORDER BY a.created_at DESC`,
+ *       [userId],
+ *     );
+ *     return result.rows;
+ *   }
+ *
+ *   // МЕНЯТЬ: поля SELECT для администратора
+ *   async findAll() {
+ *     const result = await this.pool.query(
+ *       `SELECT a.*, u.login, u.full_name, u.email, u.phone
+ *        FROM applications a
+ *        JOIN users u ON u.id = a.user_id
+ *        ORDER BY a.created_at DESC`,
+ *     );
+ *     return result.rows;
+ *   }
+ *
+ *   // МЕНЯТЬ: поле status если другое название
+ *   async updateStatus(id: number, status: string, isAdmin: boolean) {
+ *     if (!isAdmin) throw new ForbiddenException('Только для администратора');
+ *     const result = await this.pool.query(
+ *       `UPDATE applications SET status = $1 WHERE id = $2 RETURNING *`,
+ *       [status, id],
+ *     );
+ *     if (result.rows.length === 0) throw new NotFoundException('Запись не найдена');
+ *     return result.rows[0];
+ *   }
+ *
+ *   async delete(id: number, userId: number, isAdmin: boolean) {
+ *     const check = await this.pool.query('SELECT * FROM applications WHERE id = $1', [id]);
+ *     if (check.rows.length === 0) throw new NotFoundException('Запись не найдена');
+ *     if (!isAdmin && check.rows[0].user_id !== userId) throw new ForbiddenException('Нет доступа');
+ *     await this.pool.query('DELETE FROM applications WHERE id = $1', [id]);
+ *     return { success: true };
+ *   }
+ * }
+ * ```
+ */
+export declare const BE_appsService: string;
+
+/**
+ * **FILE: native/src/applications/applications.controller.ts** — роуты заявок
+ *
+ * МЕНЯТЬ: `'applications'` на своё название маршрута, поля body
+ * @example
+ * ```typescript
+ * import { Controller, Get, Post, Patch, Delete, Body, Param, UseGuards, Request } from '@nestjs/common';
+ * import { ApplicationsService } from './applications.service';
+ * import { JwtAuthGuard } from '../auth/jwt-auth.guard';
+ *
+ * // МЕНЯТЬ: 'applications' на своё название (например 'orders')
+ * @UseGuards(JwtAuthGuard)
+ * @Controller('applications')
+ * export class ApplicationsController {
+ *   constructor(private readonly svc: ApplicationsService) {}
+ *
+ *   // POST /applications — создать запись
+ *   // МЕНЯТЬ: поля body под свою тему
+ *   @Post()
+ *   create(@Request() req, @Body() body: {
+ *     course_name: string;
+ *     desired_start_date: string;
+ *     payment_method: string;
+ *   }) {
+ *     return this.svc.create(req.user.id, body);
+ *   }
+ *
+ *   // ВАЖНО: /my должен быть выше /:id
+ *   @Get('my')
+ *   findMy(@Request() req) {
+ *     return this.svc.findByUser(req.user.id);
+ *   }
+ *
+ *   @Get()
+ *   findAll() {
+ *     return this.svc.findAll();
+ *   }
+ *
+ *   // МЕНЯТЬ: 'status' если другое поле обновляется
+ *   @Patch(':id/status')
+ *   updateStatus(@Param('id') id: string, @Body() body: { status: string }, @Request() req) {
+ *     return this.svc.updateStatus(+id, body.status, req.user.is_admin);
+ *   }
+ *
+ *   @Delete(':id')
+ *   delete(@Param('id') id: string, @Request() req) {
+ *     return this.svc.delete(+id, req.user.id, req.user.is_admin);
+ *   }
+ * }
+ * ```
+ */
+export declare const BE_appsController: string;
+
+/**
+ * **FILE: native/src/reviews/reviews.service.ts** и **reviews.controller.ts**
+ *
+ * МЕНЯТЬ: таблицу `reviews`, поля
+ * @example
+ * ```typescript
+ * // reviews.service.ts
+ * import { Injectable, Inject } from '@nestjs/common';
+ * import { Pool } from 'pg';
+ * import { DB_POOL } from '../database/database.module';
+ *
+ * @Injectable()
+ * export class ReviewsService {
+ *   constructor(@Inject(DB_POOL) private readonly pool: Pool) {}
+ *
+ *   // МЕНЯТЬ: таблицу reviews, поля INSERT
+ *   async create(userId: number, dto: { application_id: number; review_text: string }) {
+ *     const result = await this.pool.query(
+ *       `INSERT INTO reviews (application_id, user_id, review_text)
+ *        VALUES ($1, $2, $3) RETURNING *`,
+ *       [dto.application_id, userId, dto.review_text],
+ *     );
+ *     return result.rows[0];
+ *   }
+ *
+ *   async findByApplication(applicationId: number) {
+ *     const result = await this.pool.query(
+ *       'SELECT * FROM reviews WHERE application_id = $1',
+ *       [applicationId],
+ *     );
+ *     return result.rows;
+ *   }
+ *
+ *   async delete(id: number) {
+ *     await this.pool.query('DELETE FROM reviews WHERE id = $1', [id]);
+ *     return { success: true };
+ *   }
+ * }
+ *
+ * // reviews.controller.ts
+ * import { Controller, Post, Get, Delete, Body, Param, UseGuards, Request } from '@nestjs/common';
+ * import { ReviewsService } from './reviews.service';
+ * import { JwtAuthGuard } from '../auth/jwt-auth.guard';
+ *
+ * @UseGuards(JwtAuthGuard)
+ * @Controller('reviews')
+ * export class ReviewsController {
+ *   constructor(private readonly svc: ReviewsService) {}
+ *
+ *   @Post()
+ *   create(@Request() req, @Body() body: { application_id: number; review_text: string }) {
+ *     return this.svc.create(req.user.id, body);
+ *   }
+ *
+ *   @Get(':applicationId')
+ *   findByApplication(@Param('applicationId') id: string) {
+ *     return this.svc.findByApplication(+id);
+ *   }
+ *
+ *   @Delete(':id')
+ *   delete(@Param('id') id: string) {
+ *     return this.svc.delete(+id);
+ *   }
+ * }
+ * ```
+ */
+export declare const BE_reviewsService: string;
+
+/**
+ * **FILE: native/src/database/init.sql** — создание таблиц в PostgreSQL
+ *
+ * МЕНЯТЬ: таблицы applications (поля), reviews (поля). Таблицу users НЕ МЕНЯТЬ.
+ * Запустить один раз в pgAdmin (Query Tool) или через psql.
+ * @example
+ * ```sql
+ * -- Таблица пользователей — НЕ МЕНЯТЬ
+ * CREATE TABLE IF NOT EXISTS users (
+ *   id SERIAL PRIMARY KEY,
+ *   login VARCHAR(50) UNIQUE NOT NULL,
+ *   password_hash VARCHAR(255) NOT NULL,
+ *   full_name VARCHAR(200) NOT NULL,
+ *   phone VARCHAR(20) NOT NULL,
+ *   email VARCHAR(100) NOT NULL,
+ *   is_admin BOOLEAN DEFAULT FALSE,
+ *   created_at TIMESTAMP DEFAULT NOW()
+ * );
+ *
+ * -- МЕНЯТЬ: поля таблицы applications под свою тему
+ * -- Обязательно оставить: id, user_id, status, created_at
+ * CREATE TABLE IF NOT EXISTS applications (
+ *   id SERIAL PRIMARY KEY,
+ *   user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+ *   course_name VARCHAR(200) NOT NULL,        -- МЕНЯТЬ
+ *   desired_start_date DATE NOT NULL,          -- МЕНЯТЬ
+ *   payment_method VARCHAR(20) NOT NULL CHECK (payment_method IN ('cash', 'transfer')), -- МЕНЯТЬ
+ *   status VARCHAR(30) DEFAULT 'new' CHECK (status IN ('new', 'in_progress', 'completed')), -- МЕНЯТЬ статусы
+ *   created_at TIMESTAMP DEFAULT NOW()
+ * );
+ *
+ * -- МЕНЯТЬ: поля таблицы reviews под свою тему
+ * -- Обязательно оставить: id, application_id, user_id, created_at
+ * CREATE TABLE IF NOT EXISTS reviews (
+ *   id SERIAL PRIMARY KEY,
+ *   application_id INTEGER REFERENCES applications(id) ON DELETE CASCADE,
+ *   user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+ *   review_text TEXT NOT NULL,                -- МЕНЯТЬ
+ *   created_at TIMESTAMP DEFAULT NOW()
+ * );
+ *
+ * -- Создать администратора (после создания таблиц запустить create-admin.js):
+ * -- node create-admin.js
+ * ```
+ */
+export declare const BE_initSQL: string;
+
+
+// ==================== FRONTEND ====================
+
+/**
+ * **FILE: lib/src/app/app.routes.ts** — маршруты Angular
+ *
+ * МЕНЯТЬ: `'applications'` на своё название, путь `applications/new`, компоненты
+ * @example
+ * ```typescript
+ * import { Routes } from '@angular/router';
+ * import { authGuard } from './guards/auth.guard';
+ * import { adminGuard } from './guards/admin.guard';
+ *
+ * export const routes: Routes = [
+ *   { path: '', redirectTo: '/login', pathMatch: 'full' },
+ *
+ *   { path: 'login',    loadComponent: () => import('./pages/login/login.component').then(m => m.LoginComponent) },
+ *   { path: 'register', loadComponent: () => import('./pages/register/register.component').then(m => m.RegisterComponent) },
+ *
+ *   // МЕНЯТЬ: 'applications' на своё название маршрута
+ *   {
+ *     path: 'applications',
+ *     loadComponent: () => import('./pages/applications/applications.component').then(m => m.ApplicationsComponent),
+ *     canActivate: [authGuard],
+ *   },
+ *   {
+ *     path: 'applications/new', // МЕНЯТЬ: путь создания новой записи
+ *     loadComponent: () => import('./pages/create-application/create-application.component').then(m => m.CreateApplicationComponent),
+ *     canActivate: [authGuard],
+ *   },
+ *   {
+ *     path: 'admin',
+ *     loadComponent: () => import('./pages/admin/admin.component').then(m => m.AdminComponent),
+ *     canActivate: [adminGuard],
+ *   },
+ *
+ *   { path: '**', redirectTo: '/login' },
+ * ];
+ * ```
+ */
+export declare const FE_routes: string;
+
+/**
+ * **FILE: lib/src/app/app.config.ts** и **app.ts** — конфигурация Angular
+ *
+ * НЕ МЕНЯТЬ эти файлы
+ * @example
+ * ```typescript
+ * // app.config.ts — НЕ МЕНЯТЬ
+ * import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
+ * import { provideRouter } from '@angular/router';
+ * import { provideHttpClient, withInterceptors } from '@angular/common/http';
+ * import { provideAnimationsAsync } from '@angular/platform-browser/animations/async';
+ * import { providePrimeNG } from 'primeng/config';
+ * import Aura from '@primeng/themes/aura';
+ * import { routes } from './app.routes';
+ * import { authInterceptor } from './interceptors/auth.interceptor';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideBrowserGlobalErrorListeners(),
+ *     provideRouter(routes),
+ *     provideHttpClient(withInterceptors([authInterceptor])),
+ *     provideAnimationsAsync(),
+ *     providePrimeNG({ theme: { preset: Aura } }),
+ *   ],
+ * };
+ *
+ * // app.ts — НЕ МЕНЯТЬ
+ * import { Component } from '@angular/core';
+ * import { RouterOutlet } from '@angular/router';
+ * import { Toast } from 'primeng/toast';
+ * import { MessageService } from 'primeng/api';
+ *
+ * @Component({
+ *   selector: 'app-root',
+ *   imports: [RouterOutlet, Toast],
+ *   providers: [MessageService],
+ *   template: `<p-toast position="bottom-right" /><router-outlet />`,
+ * })
+ * export class App {}
+ * ```
+ */
+export declare const FE_config: string;
+
+/**
+ * **FILE: lib/src/app/services/auth.service.ts** — сервис авторизации
+ *
+ * НЕ МЕНЯТЬ (кроме адреса API если другой порт)
+ * @example
+ * ```typescript
+ * import { Injectable, signal } from '@angular/core';
+ * import { HttpClient } from '@angular/common/http';
+ * import { Router } from '@angular/router';
+ * import { tap } from 'rxjs';
+ *
+ * const API = 'http://localhost:3000'; // МЕНЯТЬ только если другой порт бэкенда
+ *
+ * @Injectable({ providedIn: 'root' })
+ * export class AuthService {
+ *   currentUser = signal<any>(null); // реактивный сигнал с текущим пользователем
+ *
+ *   constructor(private http: HttpClient, private router: Router) {
+ *     const stored = localStorage.getItem('user');
+ *     if (stored) this.currentUser.set(JSON.parse(stored));
+ *   }
+ *
+ *   register(data: any) {
+ *     return this.http.post<any>(`${API}/auth/register`, data).pipe(
+ *       tap(res => this.saveSession(res)),
+ *     );
+ *   }
+ *
+ *   login(login: string, password: string) {
+ *     return this.http.post<any>(`${API}/auth/login`, { login, password }).pipe(
+ *       tap(res => this.saveSession(res)),
+ *     );
+ *   }
+ *
+ *   logout() {
+ *     localStorage.clear();
+ *     this.currentUser.set(null);
+ *     this.router.navigate(['/login']);
+ *   }
+ *
+ *   isAdmin() { return this.currentUser()?.is_admin === true; }
+ *   isLoggedIn() { return !!localStorage.getItem('token'); }
+ *
+ *   private saveSession(res: any) {
+ *     localStorage.setItem('token', res.token);
+ *     localStorage.setItem('user', JSON.stringify(res.user));
+ *     this.currentUser.set(res.user);
+ *   }
+ * }
+ * ```
+ */
+export declare const FE_authService: string;
+
+/**
+ * **FILE: lib/src/app/services/applications.service.ts** — HTTP-запросы к заявкам
+ *
+ * МЕНЯТЬ: `'applications'` на своё название маршрута
+ * @example
+ * ```typescript
+ * import { Injectable } from '@angular/core';
+ * import { HttpClient } from '@angular/common/http';
+ *
+ * const API = 'http://localhost:3000';
+ *
+ * @Injectable({ providedIn: 'root' })
+ * export class ApplicationsService {
+ *   constructor(private http: HttpClient) {}
+ *
+ *   // МЕНЯТЬ: 'applications' на своё название в каждом методе
+ *   create(data: any)                        { return this.http.post(`${API}/applications`, data); }
+ *   getMy()                                  { return this.http.get<any[]>(`${API}/applications/my`); }
+ *   getAll()                                 { return this.http.get<any[]>(`${API}/applications`); }
+ *   updateStatus(id: number, status: string) { return this.http.patch(`${API}/applications/${id}/status`, { status }); }
+ *   delete(id: number)                       { return this.http.delete(`${API}/applications/${id}`); }
+ * }
+ * ```
+ */
+export declare const FE_appsService: string;
+
+/**
+ * **FILE: lib/src/app/services/reviews.service.ts** — HTTP-запросы к отзывам
+ *
+ * МЕНЯТЬ: поля dto если другая структура отзыва
+ * @example
+ * ```typescript
+ * import { Injectable } from '@angular/core';
+ * import { HttpClient } from '@angular/common/http';
+ *
+ * const API = 'http://localhost:3000';
+ *
+ * @Injectable({ providedIn: 'root' })
+ * export class ReviewsService {
+ *   constructor(private http: HttpClient) {}
+ *
+ *   create(data: { application_id: number; review_text: string }) {
+ *     return this.http.post(`${API}/reviews`, data);
+ *   }
+ *
+ *   getByApplication(appId: number) {
+ *     return this.http.get<any[]>(`${API}/reviews/${appId}`);
+ *   }
+ * }
+ * ```
+ */
+export declare const FE_reviewsService: string;
+
+/**
+ * **FILE: auth.interceptor.ts** + **auth.guard.ts** + **admin.guard.ts**
+ *
+ * НЕ МЕНЯТЬ эти файлы
+ * @example
+ * ```typescript
+ * // interceptors/auth.interceptor.ts — автоматически добавляет Bearer токен
+ * import { HttpInterceptorFn } from '@angular/common/http';
+ *
+ * export const authInterceptor: HttpInterceptorFn = (req, next) => {
+ *   const token = localStorage.getItem('token');
+ *   if (token) {
+ *     req = req.clone({ setHeaders: { Authorization: `Bearer ${token}` } });
+ *   }
+ *   return next(req);
+ * };
+ *
+ * // guards/auth.guard.ts — только авторизованные
+ * import { inject } from '@angular/core';
+ * import { CanActivateFn, Router } from '@angular/router';
+ * import { AuthService } from '../services/auth.service';
+ *
+ * export const authGuard: CanActivateFn = () => {
+ *   const auth = inject(AuthService);
+ *   const router = inject(Router);
+ *   if (auth.isLoggedIn()) return true;
+ *   return router.createUrlTree(['/login']);
+ * };
+ *
+ * // guards/admin.guard.ts — только администратор
+ * export const adminGuard: CanActivateFn = () => {
+ *   const auth = inject(AuthService);
+ *   const router = inject(Router);
+ *   if (auth.isLoggedIn() && auth.isAdmin()) return true;
+ *   return router.createUrlTree(['/login']);
+ * };
+ * ```
+ */
+export declare const FE_interceptorGuards: string;
+
+/**
+ * **FILE: pages/login/login.component.ts** и **login.component.html**
+ *
+ * НЕ МЕНЯТЬ (форма входа универсальная)
+ * @example
+ * ```typescript
+ * // login.component.ts
+ * import { Component } from '@angular/core';
+ * import { FormBuilder, FormGroup, Validators, ReactiveFormsModule } from '@angular/forms';
+ * import { Router, RouterLink } from '@angular/router';
+ * import { InputTextModule } from 'primeng/inputtext';
+ * import { ButtonModule } from 'primeng/button';
+ * import { CardModule } from 'primeng/card';
+ * import { MessageModule } from 'primeng/message';
+ * import { AuthService } from '../../services/auth.service';
+ *
+ * @Component({
+ *   selector: 'app-login',
+ *   standalone: true,
+ *   imports: [ReactiveFormsModule, InputTextModule, ButtonModule, CardModule, MessageModule, RouterLink],
+ *   templateUrl: './login.component.html',
+ * })
+ * export class LoginComponent {
+ *   form: FormGroup;
+ *   error = '';
+ *   loading = false;
+ *
+ *   constructor(private fb: FormBuilder, private auth: AuthService, private router: Router) {
+ *     this.form = this.fb.group({
+ *       login: ['', Validators.required],
+ *       password: ['', Validators.required],
+ *     });
+ *   }
+ *
+ *   submit() {
+ *     if (this.form.invalid) return;
+ *     this.loading = true;
+ *     this.error = '';
+ *     const { login, password } = this.form.value;
+ *     this.auth.login(login, password).subscribe({
+ *       next: (res) => {
+ *         if (res.user.is_admin) this.router.navigate(['/admin']);
+ *         else this.router.navigate(['/applications']);
+ *       },
+ *       error: (err) => {
+ *         this.error = err.error?.message || 'Неверный логин или пароль';
+ *         this.loading = false;
+ *       },
+ *     });
+ *   }
+ * }
+ * ```
+ * @example
+ * ```html
+ * <!-- login.component.html -->
+ * <div class="auth-wrapper">
+ *   <div class="auth-card">
+ *     <h2>Вход в систему</h2>
+ *     @if (error) {
+ *       <div class="form-error" style="margin-bottom:1rem; padding:0.5rem; border:1px solid #cc0000; border-radius:4px;">
+ *         {{ error }}
+ *       </div>
+ *     }
+ *     <form [formGroup]="form" (ngSubmit)="submit()">
+ *       <div class="form-group">
+ *         <label>Логин</label>
+ *         <input pInputText formControlName="login" placeholder="Введите логин" />
+ *         @if (form.get('login')?.invalid && form.get('login')?.touched) {
+ *           <span class="form-error">Введите логин</span>
+ *         }
+ *       </div>
+ *       <div class="form-group">
+ *         <label>Пароль</label>
+ *         <input pInputText type="password" formControlName="password" placeholder="Введите пароль" />
+ *         @if (form.get('password')?.invalid && form.get('password')?.touched) {
+ *           <span class="form-error">Введите пароль</span>
+ *         }
+ *       </div>
+ *       <p-button type="submit" label="Войти" [loading]="loading" styleClass="btn-full" />
+ *       <div class="auth-link">
+ *         <a routerLink="/register">Еще не зарегистрированы? Регистрация</a>
+ *       </div>
+ *     </form>
+ *   </div>
+ * </div>
+ * ```
+ */
+export declare const FE_loginComponent: string;
+
+/**
+ * **FILE: pages/register/register.component.ts** и **register.component.html**
+ *
+ * МЕНЯТЬ: поля формы (full_name, phone, email и их валидаторы) под свою тему
+ * @example
+ * ```typescript
+ * // register.component.ts
+ * import { Component } from '@angular/core';
+ * import { FormBuilder, FormGroup, Validators, ReactiveFormsModule } from '@angular/forms';
+ * import { Router, RouterLink } from '@angular/router';
+ * import { InputTextModule } from 'primeng/inputtext';
+ * import { ButtonModule } from 'primeng/button';
+ * import { CardModule } from 'primeng/card';
+ * import { MessageModule } from 'primeng/message';
+ * import { AuthService } from '../../services/auth.service';
+ *
+ * @Component({
+ *   selector: 'app-register',
+ *   standalone: true,
+ *   imports: [ReactiveFormsModule, InputTextModule, ButtonModule, CardModule, MessageModule, RouterLink],
+ *   templateUrl: './register.component.html',
+ * })
+ * export class RegisterComponent {
+ *   form: FormGroup;
+ *   error = '';
+ *   loading = false;
+ *
+ *   constructor(private fb: FormBuilder, private auth: AuthService, private router: Router) {
+ *     this.form = this.fb.group({
+ *       login: ['', [Validators.required, Validators.minLength(6), Validators.pattern(/^[a-zA-Z0-9]+$/)]],
+ *       password: ['', [Validators.required, Validators.minLength(8)]],
+ *       full_name: ['', [Validators.required, Validators.pattern(/^[А-ЯЁа-яё\s]+$/)]],  // МЕНЯТЬ
+ *       phone: ['', [Validators.required, Validators.pattern(/^8\(\d{3}\)\d{3}-\d{2}-\d{2}$/)]],   // МЕНЯТЬ
+ *       email: ['', [Validators.required, Validators.email]],                             // МЕНЯТЬ
+ *     });
+ *   }
+ *
+ *   submit() {
+ *     if (this.form.invalid) { this.form.markAllAsTouched(); return; }
+ *     this.loading = true;
+ *     this.error = '';
+ *     this.auth.register(this.form.value).subscribe({
+ *       next: () => this.router.navigate(['/applications']),
+ *       error: (err) => {
+ *         this.error = err.error?.message || 'Ошибка регистрации';
+ *         this.loading = false;
+ *       },
+ *     });
+ *   }
+ * }
+ * ```
+ * @example
+ * ```html
+ * <!-- register.component.html — МЕНЯТЬ: поля формы, подписи, валидационные сообщения -->
+ * <div class="auth-wrapper">
+ *   <div class="auth-card" style="max-width:480px">
+ *     <h2>Регистрация</h2>
+ *     @if (error) {
+ *       <div class="form-error" style="margin-bottom:1rem; padding:0.5rem; border:1px solid #cc0000; border-radius:4px;">
+ *         {{ error }}
+ *       </div>
+ *     }
+ *     <form [formGroup]="form" (ngSubmit)="submit()">
+ *       <div class="form-group">
+ *         <label>Логин <small>(латиница и цифры, от 6 символов)</small></label>
+ *         <input pInputText formControlName="login" placeholder="mylogin123" />
+ *         @if (form.get('login')?.invalid && form.get('login')?.touched) {
+ *           <span class="form-error">Только латиница и цифры, минимум 6 символов</span>
+ *         }
+ *       </div>
+ *       <div class="form-group">
+ *         <label>Пароль <small>(минимум 8 символов)</small></label>
+ *         <input pInputText type="password" formControlName="password" placeholder="Минимум 8 символов" />
+ *         @if (form.get('password')?.invalid && form.get('password')?.touched) {
+ *           <span class="form-error">Минимум 8 символов</span>
+ *         }
+ *       </div>
+ *       <div class="form-group">
+ *         <label>ФИО <small>(кириллица и пробелы)</small></label>
+ *         <input pInputText formControlName="full_name" placeholder="Иванов Иван Иванович" />
+ *         @if (form.get('full_name')?.invalid && form.get('full_name')?.touched) {
+ *           <span class="form-error">Только кириллица и пробелы</span>
+ *         }
+ *       </div>
+ *       <div class="form-group">
+ *         <label>Телефон <small>(формат: 8(XXX)XXX-XX-XX)</small></label>
+ *         <input pInputText formControlName="phone" placeholder="8(999)123-45-67" />
+ *         @if (form.get('phone')?.invalid && form.get('phone')?.touched) {
+ *           <span class="form-error">Формат: 8(XXX)XXX-XX-XX</span>
+ *         }
+ *       </div>
+ *       <div class="form-group">
+ *         <label>Email</label>
+ *         <input pInputText type="email" formControlName="email" placeholder="example@mail.ru" />
+ *         @if (form.get('email')?.invalid && form.get('email')?.touched) {
+ *           <span class="form-error">Введите корректный email</span>
+ *         }
+ *       </div>
+ *       <p-button type="submit" label="Создать пользователя" [loading]="loading" styleClass="btn-full" />
+ *       <div class="auth-link">
+ *         <a routerLink="/login">Уже есть аккаунт? Войти</a>
+ *       </div>
+ *     </form>
+ *   </div>
+ * </div>
+ * ```
+ */
+export declare const FE_registerComponent: string;
+
+/**
+ * **FILE: pages/applications/applications.component.ts** и **.html** — список заявок пользователя
+ *
+ * МЕНЯТЬ: поля `statusLabels`, `statusSeverities`, `paymentLabels` под свои статусы/поля
+ * @example
+ * ```typescript
+ * // applications.component.ts
+ * import { Component, OnInit, ChangeDetectorRef } from '@angular/core';
+ * import { Router, RouterLink } from '@angular/router';
+ * import { FormBuilder, FormGroup, Validators, ReactiveFormsModule } from '@angular/forms';
+ * import { SlicePipe } from '@angular/common';
+ * import { ButtonModule } from 'primeng/button';
+ * import { CardModule } from 'primeng/card';
+ * import { TagModule } from 'primeng/tag';
+ * import { DialogModule } from 'primeng/dialog';
+ * import { TextareaModule } from 'primeng/textarea';
+ * import { MessageService } from 'primeng/api';
+ * import { ApplicationsService } from '../../services/applications.service';
+ * import { ReviewsService } from '../../services/reviews.service';
+ * import { AuthService } from '../../services/auth.service';
+ *
+ * @Component({
+ *   selector: 'app-applications',
+ *   standalone: true,
+ *   imports: [ReactiveFormsModule, ButtonModule, CardModule, TagModule, DialogModule, TextareaModule, RouterLink, SlicePipe],
+ *   templateUrl: './applications.component.html',
+ * })
+ * export class ApplicationsComponent implements OnInit {
+ *   applications: any[] = [];
+ *   reviewForm: FormGroup;
+ *   reviewDialogVisible = false;
+ *   selectedAppId: number | null = null;
+ *
+ *   // МЕНЯТЬ: метки и цвета статусов под свою тему
+ *   statusLabels: Record<string, string> = {
+ *     new: 'Новая',
+ *     in_progress: 'Идет обучение',
+ *     completed: 'Обучение завершено',
+ *   };
+ *   statusSeverities: Record<string, 'info' | 'warn' | 'success' | 'danger' | 'secondary'> = {
+ *     new: 'info',
+ *     in_progress: 'warn',
+ *     completed: 'success',
+ *   };
+ *   // МЕНЯТЬ: метки способов оплаты / других перечислений
+ *   paymentLabels: Record<string, string> = {
+ *     cash: 'Наличными',
+ *     transfer: 'Перевод по номеру телефона',
+ *   };
+ *
+ *   constructor(
+ *     private appsSvc: ApplicationsService,
+ *     private reviewsSvc: ReviewsService,
+ *     private auth: AuthService,
+ *     private fb: FormBuilder,
+ *     private router: Router,
+ *     private msg: MessageService,
+ *     private cdr: ChangeDetectorRef, // ВАЖНО: нужен для обновления после HTTP
+ *   ) {
+ *     this.reviewForm = this.fb.group({
+ *       review_text: ['', [Validators.required, Validators.minLength(3)]],
+ *     });
+ *   }
+ *
+ *   ngOnInit() { this.load(); }
+ *
+ *   load() {
+ *     this.appsSvc.getMy().subscribe({
+ *       next: (data) => {
+ *         this.applications = data;
+ *         this.cdr.detectChanges(); // ВАЖНО: без этого данные могут не отобразиться
+ *       },
+ *       error: (err) => console.error('Ошибка загрузки заявок:', err),
+ *     });
+ *   }
+ *
+ *   openReviewDialog(appId: number) {
+ *     this.selectedAppId = appId;
+ *     this.reviewForm.reset();
+ *     this.reviewDialogVisible = true;
+ *   }
+ *
+ *   submitReview() {
+ *     if (this.reviewForm.invalid || !this.selectedAppId) return;
+ *     this.reviewsSvc.create({
+ *       application_id: this.selectedAppId,
+ *       review_text: this.reviewForm.value.review_text,
+ *     }).subscribe({
+ *       next: () => {
+ *         this.msg.add({ severity: 'success', summary: 'Отзыв отправлен' });
+ *         this.reviewDialogVisible = false;
+ *         this.load();
+ *       },
+ *       error: () => this.msg.add({ severity: 'error', summary: 'Ошибка при отправке отзыва' }),
+ *     });
+ *   }
+ *
+ *   logout() { this.auth.logout(); }
+ * }
+ * ```
+ * @example
+ * ```html
+ * <!-- applications.component.html — МЕНЯТЬ: названия полей app.course_name, app.desired_start_date, app.payment_method -->
+ * <div class="navbar">
+ *   <span class="navbar-title">Образовательный портал</span>
+ *   <div class="flex gap-2">
+ *     <p-button label="Новая заявка" icon="pi pi-plus" routerLink="/applications/new" />
+ *     <p-button label="Выйти" severity="secondary" icon="pi pi-sign-out" (click)="logout()" />
+ *   </div>
+ * </div>
+ * <div class="page-content">
+ *   <h1 class="page-title">Мои заявки</h1>
+ *   @if (applications.length === 0) {
+ *     <div class="app-card"><p style="text-align:center; color:#666;">У вас пока нет заявок.</p></div>
+ *   }
+ *   @for (app of applications; track app.id) {
+ *     <div class="app-card">
+ *       <div class="app-card-header">
+ *         <span class="app-course-name">{{ app.course_name }}</span>
+ *         <span class="app-status app-status--{{ app.status }}">{{ statusLabels[app.status] }}</span>
+ *       </div>
+ *       <div class="app-card-body">
+ *         <p>Дата начала: <strong>{{ app.desired_start_date | slice:0:10 }}</strong></p>
+ *         <p>Оплата: <strong>{{ paymentLabels[app.payment_method] }}</strong></p>
+ *         <p class="app-created">Создана: {{ app.created_at | slice:0:10 }}</p>
+ *       </div>
+ *       @if (app.review_text) {
+ *         <div class="review-box"><strong>Ваш отзыв:</strong> {{ app.review_text }}</div>
+ *       } @else {
+ *         <p-button label="Оставить отзыв" severity="secondary" size="small" icon="pi pi-comment" (click)="openReviewDialog(app.id)" />
+ *       }
+ *     </div>
+ *   }
+ * </div>
+ * <p-dialog header="Оставить отзыв" [(visible)]="reviewDialogVisible" [modal]="true" [style]="{width: '450px'}">
+ *   <form [formGroup]="reviewForm" (ngSubmit)="submitReview()" class="flex flex-col gap-3">
+ *     <textarea pTextarea formControlName="review_text" rows="4" placeholder="Напишите ваш отзыв..." class="w-full"></textarea>
+ *     <div class="flex justify-end gap-2">
+ *       <p-button label="Отмена" severity="secondary" type="button" (click)="reviewDialogVisible = false" />
+ *       <p-button label="Отправить" type="submit" />
+ *     </div>
+ *   </form>
+ * </p-dialog>
+ * ```
+ */
+export declare const FE_applicationsComponent: string;
+
+/**
+ * **FILE: pages/create-application/create-application.component.ts** и **.html** — форма создания заявки
+ *
+ * МЕНЯТЬ: поля формы `course_name`, `desired_start_date`, `payment_method` и radiobutton значения
+ * @example
+ * ```typescript
+ * // create-application.component.ts
+ * import { Component } from '@angular/core';
+ * import { FormBuilder, FormGroup, Validators, ReactiveFormsModule } from '@angular/forms';
+ * import { Router, RouterLink } from '@angular/router';
+ * import { InputTextModule } from 'primeng/inputtext';
+ * import { ButtonModule } from 'primeng/button';
+ * import { CardModule } from 'primeng/card';
+ * import { RadioButtonModule } from 'primeng/radiobutton';
+ * import { DatePickerModule } from 'primeng/datepicker';
+ * import { MessageService } from 'primeng/api';
+ * import { ApplicationsService } from '../../services/applications.service';
+ *
+ * @Component({
+ *   selector: 'app-create-application',
+ *   standalone: true,
+ *   imports: [ReactiveFormsModule, InputTextModule, ButtonModule, CardModule, RadioButtonModule, DatePickerModule, RouterLink],
+ *   templateUrl: './create-application.component.html',
+ * })
+ * export class CreateApplicationComponent {
+ *   form: FormGroup;
+ *   loading = false;
+ *
+ *   constructor(private fb: FormBuilder, private appsSvc: ApplicationsService, private router: Router, private msg: MessageService) {
+ *     this.form = this.fb.group({
+ *       course_name: ['', Validators.required],         // МЕНЯТЬ: поле 1
+ *       desired_start_date: [null, Validators.required], // МЕНЯТЬ: поле даты
+ *       payment_method: ['cash', Validators.required],   // МЕНЯТЬ: поле с вариантами
+ *     });
+ *   }
+ *
+ *   submit() {
+ *     if (this.form.invalid) { this.form.markAllAsTouched(); return; }
+ *     this.loading = true;
+ *     const val = this.form.value;
+ *     // ВАЖНО: конвертация Date -> строка YYYY-MM-DD для API
+ *     const date: Date = val.desired_start_date;
+ *     const dateStr = `${date.getFullYear()}-${String(date.getMonth()+1).padStart(2,'0')}-${String(date.getDate()).padStart(2,'0')}`;
+ *     this.appsSvc.create({ ...val, desired_start_date: dateStr }).subscribe({
+ *       next: () => {
+ *         this.msg.add({ severity: 'success', summary: 'Заявка отправлена на рассмотрение' });
+ *         setTimeout(() => this.router.navigate(['/applications']), 1000);
+ *       },
+ *       error: () => {
+ *         this.msg.add({ severity: 'error', summary: 'Ошибка при создании заявки' });
+ *         this.loading = false;
+ *       },
+ *     });
+ *   }
+ * }
+ * ```
+ * @example
+ * ```html
+ * <!-- create-application.component.html — МЕНЯТЬ: поля формы, label, placeholder, radiobutton значения -->
+ * <div class="auth-wrapper">
+ *   <div class="auth-card" style="max-width:480px">
+ *     <h2>Новая заявка на обучение</h2>
+ *     <form [formGroup]="form" (ngSubmit)="submit()">
+ *       <div class="form-group">
+ *         <label>Наименование курса</label>
+ *         <input pInputText formControlName="course_name" placeholder="Введите название курса" />
+ *         @if (form.get('course_name')?.invalid && form.get('course_name')?.touched) {
+ *           <span class="form-error">Введите название курса</span>
+ *         }
+ *       </div>
+ *       <div class="form-group">
+ *         <label>Желаемая дата начала обучения</label>
+ *         <p-datepicker formControlName="desired_start_date" dateFormat="dd.mm.yy" [showIcon]="true" placeholder="Выберите дату" styleClass="w-full" />
+ *         @if (form.get('desired_start_date')?.invalid && form.get('desired_start_date')?.touched) {
+ *           <span class="form-error">Укажите дату</span>
+ *         }
+ *       </div>
+ *       <div class="form-group">
+ *         <label>Способ оплаты</label>
+ *         <div class="radio-group">
+ *           <div class="radio-option">
+ *             <p-radiobutton formControlName="payment_method" value="cash" inputId="cash" />
+ *             <label for="cash">Наличными</label>
+ *           </div>
+ *           <div class="radio-option">
+ *             <p-radiobutton formControlName="payment_method" value="transfer" inputId="transfer" />
+ *             <label for="transfer">Переводом по номеру телефона</label>
+ *           </div>
+ *         </div>
+ *       </div>
+ *       <div class="btn-row">
+ *         <p-button label="Отмена" severity="secondary" type="button" routerLink="/applications" styleClass="btn-half" />
+ *         <p-button label="Отправить" type="submit" [loading]="loading" styleClass="btn-half" />
+ *       </div>
+ *     </form>
+ *   </div>
+ * </div>
+ * ```
+ */
+export declare const FE_createAppComponent: string;
+
+/**
+ * **FILE: pages/admin/admin.component.ts** и **.html** — панель администратора
+ *
+ * МЕНЯТЬ: `statusOptions`, `statusLabels`, `paymentLabels` под свою тему
+ * @example
+ * ```typescript
+ * // admin.component.ts
+ * import { Component, OnInit, ChangeDetectorRef } from '@angular/core';
+ * import { SlicePipe } from '@angular/common';
+ * import { ButtonModule } from 'primeng/button';
+ * import { SelectModule } from 'primeng/select';
+ * import { FormsModule } from '@angular/forms';
+ * import { MessageService } from 'primeng/api';
+ * import { ApplicationsService } from '../../services/applications.service';
+ * import { AuthService } from '../../services/auth.service';
+ *
+ * @Component({
+ *   selector: 'app-admin',
+ *   standalone: true,
+ *   imports: [ButtonModule, SelectModule, FormsModule, SlicePipe],
+ *   templateUrl: './admin.component.html',
+ * })
+ * export class AdminComponent implements OnInit {
+ *   applications: any[] = [];
+ *
+ *   // МЕНЯТЬ: варианты статусов
+ *   statusOptions = [
+ *     { label: 'Новая', value: 'new' },
+ *     { label: 'Идет обучение', value: 'in_progress' },
+ *     { label: 'Обучение завершено', value: 'completed' },
+ *   ];
+ *   statusLabels: Record<string, string> = { new: 'Новая', in_progress: 'Идет обучение', completed: 'Обучение завершено' };
+ *   statusSeverities: Record<string, 'info' | 'warn' | 'success' | 'danger' | 'secondary'> = {
+ *     new: 'info', in_progress: 'warn', completed: 'success',
+ *   };
+ *   paymentLabels: Record<string, string> = { cash: 'Наличными', transfer: 'Перевод по номеру телефона' };
+ *
+ *   constructor(private appsSvc: ApplicationsService, private auth: AuthService, private msg: MessageService, private cdr: ChangeDetectorRef) {}
+ *
+ *   ngOnInit() { this.load(); }
+ *
+ *   load() {
+ *     this.appsSvc.getAll().subscribe({
+ *       next: (data) => { this.applications = data; this.cdr.detectChanges(); },
+ *       error: (err) => console.error('Ошибка загрузки:', err),
+ *     });
+ *   }
+ *
+ *   changeStatus(app: any, newStatus: string) {
+ *     this.appsSvc.updateStatus(app.id, newStatus).subscribe({
+ *       next: (updated: any) => {
+ *         app.status = updated.status;
+ *         this.msg.add({ severity: 'success', summary: 'Статус обновлён' });
+ *         this.cdr.detectChanges();
+ *       },
+ *       error: () => this.msg.add({ severity: 'error', summary: 'Ошибка обновления' }),
+ *     });
+ *   }
+ *
+ *   logout() { this.auth.logout(); }
+ * }
+ * ```
+ * @example
+ * ```html
+ * <!-- admin.component.html — МЕНЯТЬ: поля app.course_name, app.desired_start_date, app.payment_method, app.full_name -->
+ * <div class="navbar">
+ *   <span class="navbar-title">Образовательный портал — Администратор</span>
+ *   <p-button label="Выйти" severity="secondary" icon="pi pi-sign-out" (click)="logout()" />
+ * </div>
+ * <div class="page-content">
+ *   <h1 class="page-title">Все заявки</h1>
+ *   @if (applications.length === 0) {
+ *     <div class="app-card"><p style="text-align:center; color:#666;">Заявок пока нет</p></div>
+ *   }
+ *   @for (app of applications; track app.id) {
+ *     <div class="app-card">
+ *       <div class="app-card-header">
+ *         <span class="app-course-name">{{ app.course_name }}</span>
+ *         <span class="app-status app-status--{{ app.status }}">{{ statusLabels[app.status] }}</span>
+ *       </div>
+ *       <div class="app-card-body">
+ *         <p>Пользователь: <strong>{{ app.full_name }}</strong> ({{ app.login }})</p>
+ *         <p>Email: <strong>{{ app.email }}</strong></p>
+ *         <p>Телефон: <strong>{{ app.phone }}</strong></p>
+ *         <p>Дата начала: <strong>{{ app.desired_start_date | slice:0:10 }}</strong></p>
+ *         <p>Оплата: <strong>{{ paymentLabels[app.payment_method] }}</strong></p>
+ *         <p class="app-created">Создана: {{ app.created_at | slice:0:10 }}</p>
+ *       </div>
+ *       <div class="admin-status-row">
+ *         <label>Изменить статус:</label>
+ *         <p-select [options]="statusOptions" [(ngModel)]="app.status" optionLabel="label" optionValue="value" (onChange)="changeStatus(app, app.status)" />
+ *       </div>
+ *     </div>
+ *   }
+ * </div>
+ * ```
+ */
+export declare const FE_adminComponent: string;
+
+/**
+ * **FILE: lib/src/styles.scss** — глобальные стили (PrimeNG + кастомные)
+ *
+ * НЕ МЕНЯТЬ (можно менять цвет --primary для другой темы)
+ * @example
+ * ```scss
+ * @import "primeicons/primeicons.css";
+ *
+ * :root {
+ *   --primary: #2563eb;       // МЕНЯТЬ: основной цвет
+ *   --primary-hover: #1d4ed8;
+ *   --primary-light: #eff6ff;
+ *   --bg: #f1f5f9;
+ *   --card: #ffffff;
+ *   --border: #e2e8f0;
+ *   --text: #1e293b;
+ *   --text-muted: #64748b;
+ * }
+ *
+ * * { box-sizing: border-box; margin: 0; padding: 0; }
+ * body { font-family: 'Segoe UI', system-ui, sans-serif; background: var(--bg); color: var(--text); font-size: 15px; }
+ *
+ * .p-button { background: var(--primary) !important; border-color: var(--primary) !important; color: #fff !important; border-radius: 6px !important; }
+ * .p-button:hover { background: var(--primary-hover) !important; }
+ * .p-button.p-button-secondary { background: #fff !important; border-color: var(--border) !important; color: var(--text) !important; }
+ *
+ * .p-inputtext { border: 1px solid var(--border) !important; border-radius: 6px !important; padding: 0.5rem 0.75rem !important; color: var(--text) !important; background: #fff !important; width: 100%; }
+ * .p-inputtext:focus { border-color: var(--primary) !important; box-shadow: 0 0 0 3px rgba(37,99,235,0.12) !important; outline: none !important; }
+ *
+ * .navbar { display: flex; align-items: center; justify-content: space-between; padding: 0 2rem; height: 60px; background: #fff; border-bottom: 1px solid var(--border); position: sticky; top: 0; z-index: 100; }
+ * .navbar-title { font-size: 1rem; font-weight: 600; color: var(--primary); }
+ *
+ * .page-content { max-width: 860px; margin: 0 auto; padding: 2rem 1.5rem; }
+ * .page-title { font-size: 1.4rem; font-weight: 700; margin-bottom: 1.5rem; }
+ *
+ * .app-card { background: var(--card); border: 1px solid var(--border); border-radius: 10px; padding: 1.25rem 1.5rem; margin-bottom: 1rem; box-shadow: 0 1px 3px rgba(0,0,0,0.06); }
+ * .app-card-header { display: flex; justify-content: space-between; align-items: flex-start; gap: 1rem; margin-bottom: 0.75rem; }
+ * .app-course-name { font-size: 1.05rem; font-weight: 600; color: var(--text); }
+ * .app-card-body { display: flex; flex-direction: column; gap: 0.3rem; margin-bottom: 1rem; color: var(--text-muted); font-size: 0.875rem; }
+ *
+ * .app-status { display: inline-block; padding: 0.25rem 0.65rem; border-radius: 20px; font-size: 0.75rem; font-weight: 600; }
+ * .app-status--new { background: #eff6ff; color: #2563eb; border: 1px solid #bfdbfe; }
+ * .app-status--in_progress { background: #fffbeb; color: #d97706; border: 1px solid #fde68a; }
+ * .app-status--completed { background: #f0fdf4; color: #16a34a; border: 1px solid #bbf7d0; }
+ *
+ * .auth-wrapper { display: flex; justify-content: center; align-items: center; min-height: 100vh; background: var(--bg); padding: 2rem; }
+ * .auth-card { width: 100%; max-width: 420px; background: var(--card); border: 1px solid var(--border); border-radius: 12px; padding: 2rem; box-shadow: 0 4px 16px rgba(0,0,0,0.08); }
+ * .form-group { display: flex; flex-direction: column; gap: 0.3rem; margin-bottom: 1rem; }
+ * .form-error { color: #dc2626; font-size: 0.8rem; }
+ *
+ * .radio-group { display: flex; flex-direction: column; gap: 0.5rem; margin-top: 0.25rem; }
+ * .radio-option { display: flex; align-items: center; gap: 0.5rem; cursor: pointer; }
+ * .p-radiobutton .p-radiobutton-box { border: 2px solid #cbd5e1 !important; background: #fff !important; width: 18px !important; height: 18px !important; border-radius: 50% !important; }
+ * .p-radiobutton.p-radiobutton-checked .p-radiobutton-box { border-color: var(--primary) !important; }
+ * .p-radiobutton.p-radiobutton-checked .p-radiobutton-box .p-radiobutton-icon { background: var(--primary) !important; width: 8px !important; height: 8px !important; border-radius: 50% !important; }
+ *
+ * .p-select { border: 1px solid var(--border) !important; border-radius: 6px !important; background: #fff !important; }
+ * .p-select-overlay { background: #fff !important; border: 1px solid var(--border) !important; border-radius: 8px !important; }
+ * .p-select-option { background: #fff !important; color: var(--text) !important; }
+ * .p-select-option.p-select-option-selected { background: var(--primary) !important; color: #fff !important; }
+ *
+ * .p-dialog { border: 1px solid var(--border) !important; border-radius: 12px !important; background: #fff !important; }
+ * .p-dialog .p-dialog-header { border-bottom: 1px solid var(--border) !important; font-weight: 600 !important; background: #fff !important; }
+ * .p-dialog .p-dialog-content { background: #fff !important; color: var(--text) !important; padding: 1.25rem !important; }
+ *
+ * .btn-full { width: 100%; margin-top: 0.5rem; }
+ * .btn-full .p-button { width: 100%; justify-content: center; }
+ * .btn-row { display: flex; gap: 0.75rem; margin-top: 0.5rem; }
+ * .btn-half { flex: 1; }
+ * .btn-half .p-button { width: 100%; justify-content: center; }
+ *
+ * .admin-status-row { display: flex; align-items: center; gap: 0.75rem; margin-top: 0.75rem; padding-top: 0.75rem; border-top: 1px solid var(--border); }
+ *
+ * .review-box { padding: 0.75rem 1rem; background: #f0fdf4; border-left: 3px solid #16a34a; border-radius: 0 6px 6px 0; font-size: 0.875rem; color: #166534; }
+ * ```
+ */
+export declare const FE_styles: string;