rtu-nodarbibas-api/dist/index.d.ts

NPM package for scraping RTU schedule data from nodarbibas.rtu.lv

export declare const apiClient: RTUApiClient;

export declare interface BreadcrumbItem {
    text: string;
    href: string | null;
    isActive: boolean;
}

export declare interface Course {
    id: number;
    name: string;
    code: string;
    semester: number;
    programId: number;
}

export declare interface CoursesByProgramParams {
    semesterId: number;
    programId: number;
}

export declare interface Faculty {
    facultyName: string;
    facultyCode: string;
    programs: Program[];
}

export declare interface FacultyInfo {
    name: string;
    code: string;
    programCount: number;
}

export declare interface Group {
    id: number;
    name: string;
    studentCount: number;
    courseId: number;
}

export declare interface GroupsByCourseParams {
    courseId: number;
    semesterId: number;
    programId: number;
}

export declare const htmlParser: RTUHtmlParser;

export declare interface PageMetadata {
    title: string;
    description: string;
    keywords: string;
    charset: string;
}

export declare interface Pagination {
    currentPage: number;
    totalPages: number;
    hasNext: boolean;
    hasPrevious: boolean;
    nextUrl: string | null;
    previousUrl: string | null;
}

export declare interface Program {
    id: number;
    name: string;
    code: string;
    tokens: string;
}

/**
 * RTU API Client for making POST requests to backend endpoints
 * All methods in this class fetch live data from the RTU scheduling system
 */
export declare class RTUApiClient {
    private client;
    private cache;
    private readonly cacheTimeout;
    constructor(config?: RTUApiConfig);
    /**
     * Fetch semester program events for a specific month and year
     * @param params Parameters including semesterProgramId, year, and month
     * @returns Array of semester events
     */
    fetchSemesterProgramEvents(params: SemesterProgramEventsParams): Promise<SemesterEvent[]>;
    /**
     * Fetch subjects for a semester program
     * @param semesterProgramId The ID of the semester program
     * @returns Array of subjects
     */
    fetchSemesterProgramSubjects(semesterProgramId: number): Promise<Subject[]>;
    /**
     * Check if a semester program schedule is published
     * @param semesterProgramId The ID of the semester program
     * @returns Boolean indicating if the program is published
     */
    checkSemesterProgramPublished(semesterProgramId: number): Promise<boolean>;
    /**
     * Find groups associated with a specific course
     * @param params Parameters including courseId, semesterId, and programId
     * @returns Array of groups
     */
    findGroupsByCourse(params: GroupsByCourseParams): Promise<Group[]>;
    /**
     * Find courses available in a specific program
     * @param params Parameters including semesterId and programId
     * @returns Array of courses
     */
    findCoursesByProgram(params: CoursesByProgramParams): Promise<Course[]>;
    /**
     * Clear all cached data
     */
    clearCache(): void;
    /**
     * Clear expired cache entries
     */
    clearExpiredCache(): void;
    private validateSemesterProgramEventsParams;
    private validateGroupsByCourseParams;
    private validateCoursesByProgramParams;
    private getFromCache;
    private setCache;
}

export declare interface RTUApiConfig {
    baseUrl?: string;
    timeout?: number;
    userAgent?: string;
    cacheTimeout?: number;
}

/**
 * RTU HTML Parser for extracting structured data from hardcoded HTML
 * All methods in this class parse static HTML content from the RTU website
 */
export declare class RTUHtmlParser {
    /**
     * Parse semester options from HTML select element
     * @param html HTML content containing semester select
     * @returns Array of parsed semesters
     */
    parseHtmlSemesters(html: string | null | undefined): Semester[];
    /**
     * Parse hidden semester metadata from HTML inputs
     * @param html HTML content containing semester metadata
     * @returns Semester metadata object
     */
    parseHtmlSemesterMetadata(html: string): SemesterMetadata;
    /**
     * Parse program options grouped by faculty from HTML select
     * @param html HTML content containing program select
     * @returns Array of faculties with their programs
     */
    parseHtmlPrograms(html: string): Faculty[];
    /**
     * Parse schedule table data from HTML table
     * @param html HTML content containing schedule table
     * @returns Array of schedule events
     */
    parseHtmlScheduleTable(html: string): ScheduleEvent[];
    /**
     * Parse faculty information from HTML
     * @param html HTML content containing faculty list
     * @returns Array of faculty information
     */
    parseHtmlFaculties(html: string): FacultyInfo[];
    /**
     * Parse breadcrumb navigation from HTML
     * @param html HTML content containing breadcrumb navigation
     * @returns Array of breadcrumb items
     */
    parseHtmlBreadcrumb(html: string): BreadcrumbItem[];
    /**
     * Parse pagination information from HTML
     * @param html HTML content containing pagination
     * @returns Pagination object
     */
    parseHtmlPagination(html: string): Pagination;
    /**
     * Parse page metadata from HTML head
     * @param html HTML content containing page metadata
     * @returns Page metadata object
     */
    parseHtmlMetadata(html: string): PageMetadata;
    /**
     * Parse time slot information from time range string
     * @param timeRange Time range string (e.g., "09:00 - 10:30")
     * @returns Time slot object with start, end, and duration
     */
    parseTimeSlot(timeRange: string): TimeSlot;
    private parseValidTimeSlot;
    /**
     * Clean and normalize text content
     * @param text Raw text content
     * @returns Normalized text
     */
    normalizeText(text: string): string;
    /**
     * Extract numeric value from text
     * @param text Text containing numbers
     * @returns Extracted number or 0 if not found
     */
    extractNumber(text: string): number;
    private extractFacultyCode;
    private extractProgramCode;
    private timeToMinutes;
}

export declare interface ScheduleEvent {
    time: string;
    subject: string;
    lecturer: string;
    location: string;
    type: string;
    group: string;
}

export declare interface Semester {
    id: number;
    name: string;
    isSelected: boolean;
}

export declare interface SemesterEvent {
    id: number;
    title: string;
    start: string;
    end: string;
    location: string;
    lecturer: string;
    type: string;
    group: string;
    course: string;
}

export declare interface SemesterMetadata {
    startDate: string;
    endDate: string;
    language: string;
}

export declare interface SemesterProgramEventsParams {
    semesterProgramId: number;
    year: number;
    month: number;
}

export declare interface Subject {
    id: number;
    name: string;
    code: string;
    credits: number;
    semester: number;
    type: string;
}

export declare interface TimeSlot {
    start: string;
    end: string;
    duration: number;
}

export { }