@campusiq/sdk/dist/index.d.ts

Official JavaScript/TypeScript SDK for CampusIQ - A comprehensive school management system API

declare abstract class BaseResource {
    protected client: CampusIQClient;
    constructor(client: CampusIQClient);
    protected requestGet<T>(endpoint: string, params?: Record<string, any>): Promise<T>;
    protected requestPost<T>(endpoint: string, data?: any): Promise<T>;
    protected requestPut<T>(endpoint: string, data?: any): Promise<T>;
    protected requestPatch<T>(endpoint: string, data?: any): Promise<T>;
    protected requestDelete<T>(endpoint: string): Promise<T>;
    private sendRequest;
}

interface PaginationParams {
    page?: number;
    limit?: number;
    sort?: string;
    order?: 'asc' | 'desc';
}
interface ListResponse<T> {
    data: T[];
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
        hasNext: boolean;
        hasPrev: boolean;
    };
}
interface Student {
    id: string;
    studentId: string;
    firstName: string;
    lastName: string;
    email: string;
    dateOfBirth: string;
    grade: string;
    status: 'active' | 'inactive' | 'graduated' | 'transferred';
    enrollmentDate: string;
    parentContact?: {
        name: string;
        email: string;
        phone: string;
    };
    address?: {
        street: string;
        city: string;
        state: string;
        zipCode: string;
    };
    createdAt: string;
    updatedAt: string;
}
interface CreateStudentData$1 {
    studentId: string;
    firstName: string;
    lastName: string;
    email: string;
    dateOfBirth: string;
    grade: string;
    parentContact?: {
        name: string;
        email: string;
        phone: string;
    };
    address?: {
        street: string;
        city: string;
        state: string;
        zipCode: string;
    };
}
interface UpdateStudentData$1 {
    firstName?: string;
    lastName?: string;
    email?: string;
    grade?: string;
    status?: 'active' | 'inactive' | 'graduated' | 'transferred';
    parentContact?: {
        name: string;
        email: string;
        phone: string;
    };
    address?: {
        street: string;
        city: string;
        state: string;
        zipCode: string;
    };
}
interface StudentFilters$1 extends PaginationParams {
    grade?: string;
    status?: string;
    search?: string;
    enrollmentDateFrom?: string;
    enrollmentDateTo?: string;
}
interface Teacher {
    id: string;
    teacherId: string;
    firstName: string;
    lastName: string;
    email: string;
    department: string;
    subjects: string[];
    hireDate: string;
    status: 'active' | 'inactive' | 'on_leave';
    phone?: string;
    address?: {
        street: string;
        city: string;
        state: string;
        zipCode: string;
    };
    createdAt: string;
    updatedAt: string;
}
interface CreateTeacherData$1 {
    teacherId: string;
    firstName: string;
    lastName: string;
    email: string;
    department: string;
    subjects: string[];
    hireDate: string;
    phone?: string;
    address?: {
        street: string;
        city: string;
        state: string;
        zipCode: string;
    };
}
interface UpdateTeacherData$1 {
    firstName?: string;
    lastName?: string;
    email?: string;
    department?: string;
    subjects?: string[];
    status?: 'active' | 'inactive' | 'on_leave';
    phone?: string;
    address?: {
        street: string;
        city: string;
        state: string;
        zipCode: string;
    };
}
interface TeacherFilters$1 extends PaginationParams {
    department?: string;
    status?: string;
    search?: string;
    subject?: string;
}
interface Course {
    id: string;
    courseId: string;
    name: string;
    description: string;
    department: string;
    credits: number;
    teacherId: string;
    teacher?: Teacher;
    semester: string;
    year: number;
    schedule: {
        days: string[];
        startTime: string;
        endTime: string;
        room: string;
    };
    capacity: number;
    enrolled: number;
    status: 'active' | 'inactive' | 'completed';
    createdAt: string;
    updatedAt: string;
}
interface CreateCourseData$1 {
    courseId: string;
    name: string;
    description: string;
    department: string;
    credits: number;
    teacherId: string;
    semester: string;
    year: number;
    schedule: {
        days: string[];
        startTime: string;
        endTime: string;
        room: string;
    };
    capacity: number;
}
interface UpdateCourseData$1 {
    name?: string;
    description?: string;
    department?: string;
    credits?: number;
    teacherId?: string;
    schedule?: {
        days: string[];
        startTime: string;
        endTime: string;
        room: string;
    };
    capacity?: number;
    status?: 'active' | 'inactive' | 'completed';
}
interface CourseFilters$1 extends PaginationParams {
    department?: string;
    teacherId?: string;
    semester?: string;
    year?: number;
    status?: string;
    search?: string;
}
interface Enrollment {
    id: string;
    studentId: string;
    courseId: string;
    student?: Student;
    course?: Course;
    enrollmentDate: string;
    status: 'enrolled' | 'dropped' | 'completed';
    grade?: string;
    credits: number;
    createdAt: string;
    updatedAt: string;
}
interface CreateEnrollmentData$1 {
    studentId: string;
    courseId: string;
    enrollmentDate?: string;
}
interface UpdateEnrollmentData$1 {
    status?: 'enrolled' | 'dropped' | 'completed';
    grade?: string;
}
interface EnrollmentFilters$1 extends PaginationParams {
    studentId?: string;
    courseId?: string;
    status?: string;
    semester?: string;
    year?: number;
    search?: string;
}
interface Grade {
    id: string;
    studentId: string;
    courseId: string;
    student?: Student;
    course?: Course;
    assignmentName: string;
    assignmentType: 'homework' | 'quiz' | 'exam' | 'project' | 'participation';
    points: number;
    maxPoints: number;
    percentage: number;
    letterGrade: string;
    gradedDate: string;
    comments?: string;
    createdAt: string;
    updatedAt: string;
}
interface CreateGradeData$1 {
    studentId: string;
    courseId: string;
    assignmentName: string;
    assignmentType: 'homework' | 'quiz' | 'exam' | 'project' | 'participation';
    points: number;
    maxPoints: number;
    gradedDate?: string;
    comments?: string;
}
interface UpdateGradeData$1 {
    assignmentName?: string;
    assignmentType?: 'homework' | 'quiz' | 'exam' | 'project' | 'participation';
    points?: number;
    maxPoints?: number;
    gradedDate?: string;
    comments?: string;
}
interface GradeFilters$1 extends PaginationParams {
    studentId?: string;
    courseId?: string;
    assignmentType?: string;
    gradedDateFrom?: string;
    gradedDateTo?: string;
    search?: string;
}
interface Attendance {
    id: string;
    studentId: string;
    courseId: string;
    student?: Student;
    course?: Course;
    date: string;
    status: 'present' | 'absent' | 'late' | 'excused';
    notes?: string;
    markedBy: string;
    markedAt: string;
    createdAt: string;
    updatedAt: string;
}
interface CreateAttendanceData$1 {
    studentId: string;
    courseId: string;
    date: string;
    status: 'present' | 'absent' | 'late' | 'excused';
    notes?: string;
}
interface UpdateAttendanceData$1 {
    status?: 'present' | 'absent' | 'late' | 'excused';
    notes?: string;
}
interface AttendanceFilters$1 extends PaginationParams {
    studentId?: string;
    courseId?: string;
    status?: string;
    dateFrom?: string;
    dateTo?: string;
    search?: string;
}
interface Webhook {
    id: string;
    url: string;
    events: string[];
    secret: string;
    status: 'active' | 'inactive';
    lastTriggered?: string;
    createdAt: string;
    updatedAt: string;
}
interface CreateWebhookData$1 {
    url: string;
    events: string[];
    secret?: string;
}
interface UpdateWebhookData$1 {
    url?: string;
    events?: string[];
    status?: 'active' | 'inactive';
}
interface WebhookFilters$1 extends PaginationParams {
    status?: string;
    event?: string;
    search?: string;
}
interface BulkOperation<T> {
    success: boolean;
    processed: number;
    errors: Array<{
        index: number;
        error: string;
        data: T;
    }>;
}
interface Statistics {
    totalStudents: number;
    totalTeachers: number;
    totalCourses: number;
    totalEnrollments: number;
    averageGPA: number;
    attendanceRate: number;
}
interface CampusIQConfig {
    apiKey: string;
    schoolId: string;
    environment?: 'production' | 'sandbox';
    baseURL?: string;
    timeout?: number;
    retries?: number;
    debug?: boolean;
}

interface CreateStudentData {
    firstName: string;
    lastName: string;
    email: string;
    grade: string;
    dateOfBirth: string;
    enrollmentDate?: string;
    address: {
        street: string;
        city: string;
        state: string;
        zipCode: string;
        country?: string;
    };
    parentContact: {
        name: string;
        email: string;
        phone: string;
        relationship?: string;
    };
    emergencyContacts?: Array<{
        name: string;
        email: string;
        phone: string;
        relationship?: string;
    }>;
    medicalInfo?: {
        allergies?: string[];
        medications?: string[];
        conditions?: string[];
    };
}
interface UpdateStudentData extends Partial<CreateStudentData> {
    status?: 'active' | 'inactive' | 'graduated';
}
interface StudentFilters extends PaginationParams {
    grade?: string;
    status?: 'active' | 'inactive' | 'graduated';
    search?: string;
    enrollmentDateFrom?: string;
    enrollmentDateTo?: string;
}
declare class StudentsResource extends BaseResource {
    /**
     * List all students with optional filtering and pagination
     */
    list(filters?: StudentFilters): Promise<ListResponse<Student>>;
    /**
     * Get a specific student by ID
     */
    get(studentId: string): Promise<Student>;
    /**
     * Create a new student
     */
    create(data: CreateStudentData): Promise<Student>;
    /**
     * Update an existing student
     */
    update(studentId: string, data: UpdateStudentData): Promise<Student>;
    /**
     * Delete a student
     */
    delete(studentId: string): Promise<{
        success: boolean;
        message: string;
    }>;
    /**
     * Get student's enrollment history
     */
    getEnrollments(studentId: string, filters?: PaginationParams): Promise<ListResponse<any>>;
    /**
     * Get student's grades
     */
    getGrades(studentId: string, filters?: PaginationParams & {
        courseId?: string;
        semester?: string;
    }): Promise<ListResponse<any>>;
    /**
     * Get student's attendance records
     */
    getAttendance(studentId: string, filters?: PaginationParams & {
        courseId?: string;
        dateFrom?: string;
        dateTo?: string;
    }): Promise<ListResponse<any>>;
    /**
     * Bulk create students
     */
    bulkCreate(students: CreateStudentData[]): Promise<{
        created: Student[];
        errors: any[];
    }>;
    /**
     * Search students by name or email
     */
    search(query: string, filters?: Omit<StudentFilters, 'search'>): Promise<ListResponse<Student>>;
}

interface CreateTeacherData {
    firstName: string;
    lastName: string;
    email: string;
    department: string;
    subjects: string[];
    hireDate: string;
    qualifications: string[];
    address?: {
        street: string;
        city: string;
        state: string;
        zipCode: string;
        country?: string;
    };
    phone?: string;
}
interface UpdateTeacherData extends Partial<CreateTeacherData> {
    status?: 'active' | 'inactive';
}
interface TeacherFilters extends PaginationParams {
    department?: string;
    status?: 'active' | 'inactive';
    search?: string;
    subject?: string;
    hireDateFrom?: string;
    hireDateTo?: string;
}
declare class TeachersResource extends BaseResource {
    /**
     * List all teachers with optional filtering and pagination
     */
    list(filters?: TeacherFilters): Promise<ListResponse<Teacher>>;
    /**
     * Get a specific teacher by ID
     */
    get(teacherId: string): Promise<Teacher>;
    /**
     * Create a new teacher
     */
    create(data: CreateTeacherData): Promise<Teacher>;
    /**
     * Update an existing teacher
     */
    update(teacherId: string, data: UpdateTeacherData): Promise<Teacher>;
    /**
     * Delete a teacher
     */
    delete(teacherId: string): Promise<{
        success: boolean;
        message: string;
    }>;
    /**
     * Get teacher's courses
     */
    getCourses(teacherId: string, filters?: PaginationParams & {
        semester?: string;
    }): Promise<ListResponse<any>>;
    /**
     * Get teacher's schedule
     */
    getSchedule(teacherId: string, filters?: {
        semester?: string;
        week?: string;
    }): Promise<any>;
    /**
     * Search teachers by name, email, or department
     */
    search(query: string, filters?: Omit<TeacherFilters, 'search'>): Promise<ListResponse<Teacher>>;
}

interface CreateCourseData {
    name: string;
    code: string;
    description: string;
    credits: number;
    department: string;
    teacherId: string;
    schedule: {
        days: string[];
        startTime: string;
        endTime: string;
        room: string;
    };
    semester: string;
    maxStudents?: number;
    prerequisites?: string[];
}
interface UpdateCourseData extends Partial<CreateCourseData> {
    status?: 'active' | 'inactive';
}
interface CourseFilters extends PaginationParams {
    department?: string;
    semester?: string;
    teacherId?: string;
    status?: 'active' | 'inactive';
    search?: string;
    credits?: number;
}
declare class CoursesResource extends BaseResource {
    /**
     * List all courses with optional filtering and pagination
     */
    list(filters?: CourseFilters): Promise<ListResponse<Course>>;
    /**
     * Get a specific course by ID
     */
    get(courseId: string): Promise<Course>;
    /**
     * Create a new course
     */
    create(data: CreateCourseData): Promise<Course>;
    /**
     * Update an existing course
     */
    update(courseId: string, data: UpdateCourseData): Promise<Course>;
    /**
     * Delete a course
     */
    delete(courseId: string): Promise<{
        success: boolean;
        message: string;
    }>;
    /**
     * Get course enrollments
     */
    getEnrollments(courseId: string, filters?: PaginationParams): Promise<ListResponse<any>>;
    /**
     * Get course grades
     */
    getGrades(courseId: string, filters?: PaginationParams & {
        studentId?: string;
    }): Promise<ListResponse<any>>;
    /**
     * Get course attendance
     */
    getAttendance(courseId: string, filters?: PaginationParams & {
        date?: string;
        status?: string;
    }): Promise<ListResponse<any>>;
    /**
     * Search courses by name, code, or description
     */
    search(query: string, filters?: Omit<CourseFilters, 'search'>): Promise<ListResponse<Course>>;
}

interface CreateEnrollmentData {
    studentId: string;
    courseId: string;
    semester: string;
    enrollmentDate?: string;
}
interface UpdateEnrollmentData {
    status?: 'enrolled' | 'dropped' | 'completed';
    grade?: string;
}
interface EnrollmentFilters extends PaginationParams {
    studentId?: string;
    courseId?: string;
    semester?: string;
    status?: 'enrolled' | 'dropped' | 'completed';
    enrollmentDateFrom?: string;
    enrollmentDateTo?: string;
}
declare class EnrollmentsResource extends BaseResource {
    /**
     * List all enrollments with optional filtering and pagination
     */
    list(filters?: EnrollmentFilters): Promise<ListResponse<Enrollment>>;
    /**
     * Get a specific enrollment by ID
     */
    get(enrollmentId: string): Promise<Enrollment>;
    /**
     * Create a new enrollment
     */
    create(data: CreateEnrollmentData): Promise<Enrollment>;
    /**
     * Update an existing enrollment
     */
    update(enrollmentId: string, data: UpdateEnrollmentData): Promise<Enrollment>;
    /**
     * Delete an enrollment
     */
    delete(enrollmentId: string): Promise<{
        success: boolean;
        message: string;
    }>;
    /**
     * Bulk enroll students in a course
     */
    bulkEnroll(courseId: string, studentIds: string[], semester: string): Promise<{
        created: Enrollment[];
        errors: any[];
    }>;
    /**
     * Drop a student from a course
     */
    drop(enrollmentId: string, reason?: string): Promise<Enrollment>;
    /**
     * Complete an enrollment (mark as completed)
     */
    complete(enrollmentId: string, finalGrade?: string): Promise<Enrollment>;
}

interface CreateGradeData {
    studentId: string;
    courseId: string;
    assignmentName: string;
    score: number;
    maxScore: number;
    weight: number;
    category: 'homework' | 'quiz' | 'exam' | 'project' | 'participation';
    gradedDate?: string;
    notes?: string;
}
interface UpdateGradeData extends Partial<Omit<CreateGradeData, 'studentId' | 'courseId'>> {
}
interface GradeFilters extends PaginationParams {
    studentId?: string;
    courseId?: string;
    category?: 'homework' | 'quiz' | 'exam' | 'project' | 'participation';
    gradedDateFrom?: string;
    gradedDateTo?: string;
    minScore?: number;
    maxScore?: number;
}
declare class GradesResource extends BaseResource {
    /**
     * List all grades with optional filtering and pagination
     */
    list(filters?: GradeFilters): Promise<ListResponse<Grade>>;
    /**
     * Get a specific grade by ID
     */
    get(gradeId: string): Promise<Grade>;
    /**
     * Create a new grade
     */
    create(data: CreateGradeData): Promise<Grade>;
    /**
     * Update an existing grade
     */
    update(gradeId: string, data: UpdateGradeData): Promise<Grade>;
    /**
     * Delete a grade
     */
    delete(gradeId: string): Promise<{
        success: boolean;
        message: string;
    }>;
    /**
     * Bulk create grades for multiple students
     */
    bulkCreate(grades: CreateGradeData[]): Promise<{
        created: Grade[];
        errors: any[];
    }>;
    /**
     * Get grade statistics for a course
     */
    getCourseStats(courseId: string, filters?: {
        category?: string;
    }): Promise<{
        average: number;
        median: number;
        highest: number;
        lowest: number;
        distribution: Record<string, number>;
    }>;
    /**
     * Get grade statistics for a student
     */
    getStudentStats(studentId: string, filters?: {
        courseId?: string;
        semester?: string;
    }): Promise<{
        gpa: number;
        totalCredits: number;
        courseGrades: Array<{
            courseId: string;
            courseName: string;
            grade: string;
            credits: number;
        }>;
    }>;
}

interface CreateAttendanceData {
    studentId: string;
    courseId: string;
    date: string;
    status: 'present' | 'absent' | 'tardy' | 'excused';
    notes?: string;
    recordedBy: string;
}
interface UpdateAttendanceData extends Partial<Omit<CreateAttendanceData, 'studentId' | 'courseId' | 'date'>> {
}
interface AttendanceFilters extends PaginationParams {
    studentId?: string;
    courseId?: string;
    status?: 'present' | 'absent' | 'tardy' | 'excused';
    startDate?: string;
    endDate?: string;
    recordedBy?: string;
}
declare class AttendanceResource extends BaseResource {
    /**
     * List all attendance records with optional filtering and pagination
     */
    list(filters?: AttendanceFilters): Promise<ListResponse<Attendance>>;
    /**
     * Get a specific attendance record by ID
     */
    getAttendance(attendanceId: string): Promise<Attendance>;
    /**
     * Create a new attendance record
     */
    createAttendance(data: CreateAttendanceData): Promise<Attendance>;
    /**
     * Update an existing attendance record
     */
    updateAttendance(attendanceId: string, data: UpdateAttendanceData): Promise<Attendance>;
    /**
     * Delete an attendance record
     */
    deleteAttendance(attendanceId: string): Promise<{
        success: boolean;
        message: string;
    }>;
    /**
     * Bulk create attendance records
     */
    bulkCreate(records: CreateAttendanceData[]): Promise<{
        created: Attendance[];
        errors: any[];
    }>;
    /**
     * Get attendance statistics for a student
     */
    getStudentStats(studentId: string, filters?: {
        courseId?: string;
        startDate?: string;
        endDate?: string;
    }): Promise<any>;
    /**
     * Get attendance statistics for a course
     */
    getCourseStats(courseId: string, filters?: {
        date?: string;
        startDate?: string;
        endDate?: string;
    }): Promise<any>;
    /**
     * Mark attendance for multiple students
     */
    markBulkAttendance(courseId: string, date: string, records: Array<{
        studentId: string;
        status: 'present' | 'absent' | 'tardy' | 'excused';
        notes?: string;
    }>): Promise<{
        created: Attendance[];
        errors: any[];
    }>;
}

interface CreateWebhookData {
    url: string;
    events: string[];
    secret?: string;
}
interface UpdateWebhookData extends Partial<CreateWebhookData> {
    status?: 'active' | 'inactive';
}
interface WebhookFilters extends PaginationParams {
    status?: 'active' | 'inactive';
    event?: string;
}
declare class WebhooksResource extends BaseResource {
    list(filters?: WebhookFilters): Promise<ListResponse<Webhook>>;
    get(webhookId: string): Promise<Webhook>;
    create(data: CreateWebhookData): Promise<Webhook>;
    update(webhookId: string, data: UpdateWebhookData): Promise<Webhook>;
    delete(webhookId: string): Promise<{
        success: boolean;
        message: string;
    }>;
    test(webhookId: string): Promise<{
        success: boolean;
        response: any;
    }>;
    getLogs(webhookId: string, filters?: PaginationParams & {
        startDate?: string;
        endDate?: string;
        status?: 'success' | 'failed';
    }): Promise<ListResponse<any>>;
    verifySignature(payload: string, signature: string, secret: string): boolean;
}

declare class CampusIQClient {
    readonly apiKey: string;
    readonly schoolId: string;
    readonly baseURL: string;
    readonly version: string;
    readonly timeout: number;
    readonly debug: boolean;
    students: StudentsResource;
    teachers: TeachersResource;
    courses: CoursesResource;
    enrollments: EnrollmentsResource;
    grades: GradesResource;
    attendance: AttendanceResource;
    webhooks: WebhooksResource;
    constructor(config: CampusIQConfig);
    static verifyWebhook(payload: any, signature: string, secret: string): boolean;
}

declare class CampusIQError extends Error {
    readonly statusCode: number;
    readonly code: string;
    readonly requestId?: string;
    constructor(message: string, statusCode?: number, code?: string, requestId?: string);
    toJSON(): Record<string, any>;
    static isNetworkError(error: any): boolean;
    static isAuthenticationError(error: any): boolean;
    static isAuthorizationError(error: any): boolean;
    static isNotFoundError(error: any): boolean;
    static isRateLimitError(error: any): boolean;
    static isServerError(error: any): boolean;
}

export { AttendanceResource, BaseResource, CampusIQClient, CampusIQError, CoursesResource, EnrollmentsResource, GradesResource, StudentsResource, TeachersResource, WebhooksResource };
export type { Attendance, AttendanceFilters$1 as AttendanceFilters, BulkOperation, CampusIQConfig, Course, CourseFilters$1 as CourseFilters, CreateAttendanceData$1 as CreateAttendanceData, CreateCourseData$1 as CreateCourseData, CreateEnrollmentData$1 as CreateEnrollmentData, CreateGradeData$1 as CreateGradeData, CreateStudentData$1 as CreateStudentData, CreateTeacherData$1 as CreateTeacherData, CreateWebhookData$1 as CreateWebhookData, Enrollment, EnrollmentFilters$1 as EnrollmentFilters, Grade, GradeFilters$1 as GradeFilters, ListResponse, PaginationParams, Statistics, Student, StudentFilters$1 as StudentFilters, Teacher, TeacherFilters$1 as TeacherFilters, UpdateAttendanceData$1 as UpdateAttendanceData, UpdateCourseData$1 as UpdateCourseData, UpdateEnrollmentData$1 as UpdateEnrollmentData, UpdateGradeData$1 as UpdateGradeData, UpdateStudentData$1 as UpdateStudentData, UpdateTeacherData$1 as UpdateTeacherData, UpdateWebhookData$1 as UpdateWebhookData, Webhook, WebhookFilters$1 as WebhookFilters };