SchoolSoft+ Node

GitHub

@elias4044/ssp-nodeis the official Node.js library for the SchoolSoft+ platform. It wraps SchoolSoft's unofficial internal REST API and gives you a clean, typed interface to authenticate, fetch schedules, assignments, lunch menus, messages, grades, attendance, and more — all without any runtime dependencies beyond Node's built-in modules.

npm install @elias4044/ssp-node

import { SchoolsoftClient } from '@elias4044/ssp-node';

const client = new SchoolsoftClient({ school: 'engelska' });

await client.login({ username: 'john.doe', password: 'mypassword' });

const lunch    = await client.getLunch(22);         // week 22
const schedule = await client.getSchedule();        // current week (auto-detected)
const news     = await client.getNews();

const client = new SchoolsoftClient({ school: 'engelska' });

await client.mobileLogin({ username: 'john.doe', password: 'mypassword' });
await client.mobileExchangeSession();   // converts access token → session cookies

const subjects = await client.getSubjects();

const result = await client.login({
  username: 'john.doe',
  password:  'secret',
  usertype:  '1',      // '1' = student (default), '2' = guardian, '3' = staff
});

console.log(result.jsessionid);   // raw JSESSIONID cookie value
console.log(result.hash);         // raw hash cookie value
console.log(result.cookieHeader); // 'JSESSIONID=...; hash=...; usertype=1'

login() — options

// Save after login
const { jsessionid, hash, usertype } = await client.login({ ... });
// e.g. store in a file, database, or environment variable

// Restore on next startup
client.setSessionCookies(jsessionid, hash, usertype);

// Optionally verify before using
const alive = await client.verifySession();
if (!alive) await client.login({ ... }); // re-authenticate if expired

const client = new SchoolsoftClient({ school: 'engelska' });

// Step 1 — obtain access + refresh tokens
const { accessToken, refreshToken, expiresAt } = await client.mobileLogin({
  username: 'john.doe',
  password:  'secret',
  orgid:     '18',    // school organisation ID, defaults to '18'
});

// Step 2 — (optional) fetch user info to get the userId for a more reliable exchange
const info = await client.fetchMobileSessionInfo();
// info: { username, firstName, lastName, email, schoolName, userType, userId }

// Step 3 — exchange the access token for session cookies
await client.mobileExchangeSession(info?.userId, {
  orgid:    '18',
  language: 'sw',       // 'sw' (Swedish) or 'en'
  theme:    'dark',
  useros:   'android',  // 'android' or 'ios'
});

// Now you can call any data endpoint
const schedule = await client.getSchedule();

mobileLogin() — options

mobileExchangeSession() — options

import { SchoolsoftClient } from '@elias4044/ssp-node';

// Step 1 — generate the auth URL and PKCE material
const flow = SchoolsoftClient.startMobileFlow({
  school:      'engelska',
  redirectUri: 'com.myapp://auth',  // your deep-link URI
  orgid:       '18',
});

console.log(flow.authUrl);   // open this in a browser or WebView
// flow.verifier — store securely on device
// flow.state    — store to verify on callback (CSRF protection)

// After the user logs in, SchoolSoft redirects to:
//   com.myapp://auth?code=XXXX&state=YYYY
// Verify flow.state === YYYY, then:

// Step 2 — complete the flow with the code from the deep-link
const client = new SchoolsoftClient({ school: 'engelska' });
await client.completeMobileFlow(code, flow.verifier);

// Step 3 — exchange for session cookies
const info = await client.fetchMobileSessionInfo();
await client.mobileExchangeSession(info?.userId);

const news = await client.getNews();

startMobileFlow() — static method options

// Manual refresh
await client.mobileRefresh();

// Check token state
console.log(client.accessToken);          // current access token string or null
console.log(client.refreshToken);         // current refresh token or null
console.log(client.isAccessTokenExpired); // boolean
console.log(client.hasMobileToken);       // true if an access token is present (any expiry)

// After mobileLogin(), persist these values
const toSave = {
  accessToken:  client.accessToken,
  refreshToken: client.refreshToken,
};

// On next startup — restore and proceed without re-logging-in
const client2 = new SchoolsoftClient({ school: 'engelska' });
client2.setAccessToken(toSave.accessToken!, toSave.refreshToken ?? undefined);

// Exchange for session cookies (auto-refreshes if access token expired)
await client2.mobileExchangeSession();

const alive = await client.verifySession();
// true  — session is valid and ready to use
// false — session has expired (need to re-authenticate)

if (!client.isAuthenticated) {
  await client.login({ username, password });
}

client.logout();
console.log(client.isAuthenticated); // false

const schools = await client.getSchools();
// Returns: School[]

// schools[0] might be:
// { id: 'engelska', name: 'Engelska Skolan Norr om Ström' }

// Find a school slug by name
const match = schools.find(s => s.name.toLowerCase().includes('carlwahren'));
console.log(match?.id); // 'carlwahren'

interface School {
  name: string;  // full display name
  id:   string;  // URL slug used in all API calls
}

const session = await client.getSession();

console.log(session.user.firstName);       // 'John'
console.log(session.user.lastName);        // 'Doe'
console.log(session.user.email);           // 'john.doe@school.se'
console.log(session.user.id);              // 12345
console.log(session.organization.name);   // 'Engelska Skolan'
console.log(session.userType);             // 'student'

interface SessionInfo {
  user: {
    userName:  string;
    firstName: string;
    lastName:  string;
    email:     string;
    id:        number;
  };
  organization: {
    name: string;
    [key: string]: unknown;
  };
  userType: string;
  school:   string;
  [key: string]: unknown;
}

const menu = await client.getLunch(22);  // week 22
// Returns: LunchMenu  (LunchDay[])

for (const day of menu) {
  console.log(day.weekDayName);                   // 'Monday', 'Tuesday', etc.
  console.log(day.lunchList?.map(l => l.name));   // ['Pasta Bolognese', 'Vegetarian option']
}

getLunch() — parameters

interface LunchDay {
  weekDay:     number;       // 1 = Monday … 5 = Friday
  weekDayName?: string;      // localised day name
  lunchList?:  LunchItem[];
  [key: string]: unknown;
}

interface LunchItem {
  name: string;
  [key: string]: unknown;
}

// Current week
const { lessons, week } = await client.getSchedule();
console.log(`Week ${week}: ${lessons.length} lessons`);

// Specific week
const { lessons: w22 } = await client.getSchedule(22);

// Each lesson
for (const lesson of lessons) {
  console.log(lesson.eventId);   // unique identifier
  console.log(lesson.startDate); // ISO 8601 date-time string
  console.log(lesson.endDate);   // ISO 8601 date-time string
  // Additional fields from SchoolSoft (subject name, room, teacher, etc.)
  // are passed through as-is under the [key: string]: unknown index signature
}

getSchedule() — parameters

interface ScheduleLesson {
  eventId:   number | string;
  startDate: string;   // ISO 8601
  endDate:   string;   // ISO 8601
  [key: string]: unknown;
}

// Current week (defaults)
const assignments = await client.getAssignmentsForWeek();

// Specific week and year
const assignments = await client.getAssignmentsForWeek(22, 2025);
// Returns: Assignment[]

for (const a of assignments) {
  console.log(a.id, a.title);
  // Fetch full details for one
  const detail = await client.getAssignment(a.id);
}

getAssignmentsForWeek() — parameters

// Default: fetch an assignment
const detail = await client.getAssignment(12345);

// Fetch a planning entry instead
const planning = await client.getAssignment(67890, 'planning');

// Full shape
console.log(detail.assignment);          // view object from SchoolSoft
console.log(detail.sections);            // sections array or null
console.log(detail.connectedPlannings);  // linked planning entries or null
console.log(detail.assessment?.review);              // teacher review text
console.log(detail.assessment?.teacherComment);      // teacher comment
console.log(detail.assessment?.studentComment);      // student comment
console.log(detail.assessment?.assessedCriteriaTabs); // graded criteria
console.log(detail.assessment?.partialMoments);       // partial assessment moments
console.log(detail.grading);             // grading object or null

getAssignment() — parameters

interface AssignmentDetail {
  assignment:         Record<string, unknown> | null;
  sections:           unknown[] | null;
  connectedPlannings: unknown[] | null;
  assessment: {
    review:              string;
    teacherComment:      string;
    studentComment:      string;
    partialMoments:      unknown[];
    assessedCriteriaTabs: unknown[];
  } | null;
  grading: unknown | null;
}

// Current week
const events = await client.getCalendarEvents();

// Specific week
const events = await client.getCalendarEvents(22);
// Returns: CalendarEvent[]

for (const ev of events) {
  console.log(ev.title);     // event title
  console.log(ev.startDate); // ISO 8601 string or undefined
  console.log(ev.endDate);   // ISO 8601 string or undefined
  console.log(ev.allDay);    // boolean — true for all-day entries
  console.log(ev.type);      // event type string from SchoolSoft
}

getCalendarEvents() — parameters

interface CalendarEvent {
  id?:        string | number;
  title?:     string;
  startDate?: string;   // ISO 8601
  endDate?:   string;   // ISO 8601
  allDay?:    boolean;
  type?:      string;
  [key: string]: unknown;
}

const subjects = await client.getSubjects();
// Returns: Subject[]

for (const sub of subjects) {
  console.log(sub.id);             // subject room ID
  console.log(sub.activityId);     // associated activity ID
  console.log(sub.unreadEntities); // number of unread items
  console.log(sub.teachers);       // array of teacher objects
  console.log(sub.entities);       // SubjectEntity[] — assignments & plannings
}

// Find entities that are assignments
const assignments = subjects
  .flatMap(s => s.entities)
  .filter(e => e.entityType === 'ASSIGNMENT');

interface Subject {
  activityId:     string;
  id:             string;
  entities:       SubjectEntity[];
  unreadEntities: number;
  teachers:       unknown[];
  [key: string]: unknown;
}

interface SubjectEntity {
  planningId?: string;
  entityType:  'PLANNING' | 'ASSIGNMENT';
  [key: string]: unknown;
}

const detail = await client.getSubject('123');

console.log(detail.subject);                   // subject metadata
console.log(detail.overview.examinations);     // upcoming examinations
console.log(detail.overview.submissions);      // pending submissions
console.log(detail.assignments);               // all assignments for the subject

getSubject() — parameters

const news = await client.getNews();
// Returns: NewsItem[]

for (const item of news) {
  console.log(item.id);      // news item ID (string) or null if not found
  console.log(item.title);   // news headline
  console.log(item.preview); // short preview text or null
}

const article = await client.getNewsDetail('42');
if (article) {
  console.log(article.id);           // '42'
  console.log(article.title);        // article headline
  console.log(article.body);         // raw HTML body of the article
  console.log(article.date);         // date string or null
  console.log(article.attachments);  // [{ name, url }, ...]
}

getNewsDetail() — parameters

interface NewsDetail {
  id:          string;
  title:       string;
  body:        string;         // raw HTML
  date:        string | null;
  attachments: Array<{ name: string; url: string }>;
}

const { homework, tests } = await client.getStartpage();

// Upcoming homework
for (const hw of homework) {
  console.log(hw.dateAndSubject); // e.g. 'Monday — Mathematics'
  console.log(hw.title);          // assignment/homework title
  console.log(hw.content);        // string[] — lines of the description
}

// Recent test results
for (const test of tests) {
  console.log(test.title);       // test name
  console.log(test.description); // grade / result text
  console.log(test.link);        // URL to the test detail page, if available
}

interface StartpageData {
  homework: StartpageHomework[];
  tests:    StartpageTest[];
}

interface StartpageHomework {
  dateAndSubject: string;
  title:          string;
  content:        string[];
}

interface StartpageTest {
  title:       string;
  description: string;
  link:        string | undefined;
}

const students = await client.getClassStudents();
// Returns: ClassStudent[]

for (const s of students) {
  console.log(s.name);    // full display name
  console.log(s.email);   // email address, or null
  console.log(s.address); // home address, or null
}

interface ClassStudent {
  name:    string;
  email:   string | null;
  address: string | null;
}

const messages = await client.getInbox();
// Returns: Message[]

for (const msg of messages) {
  console.log(msg.id);         // message ID
  console.log(msg.subject);    // message subject line
  console.log(msg.senderName); // display name of the sender
  console.log(msg.date);       // date string from SchoolSoft
  console.log(msg.read);       // boolean — whether the message has been read
}

const sent = await client.getOutbox();
// Returns: Message[]

interface Message {
  id:          string | number;
  subject:     string;
  senderName?: string;
  senderId?:   string | number;
  date?:       string;
  read?:       boolean;
  [key: string]: unknown;
}

const detail = await client.getMessage(42);
if (detail) {
  console.log(detail.subject);       // subject line
  console.log(detail.body);          // full message body text
  console.log(detail.recipients);    // MessageRecipient[]
  console.log(detail.attachments);   // MessageAttachment[]
}

getMessage() — parameters

interface MessageDetail extends Message {
  body:          string;
  recipients?:   MessageRecipient[];
  attachments?:  MessageAttachment[];
  [key: string]: unknown;
}

interface MessageRecipient {
  id:    string | number;
  name:  string;
  type?: string;
}

interface MessageAttachment {
  id:   string | number;
  name: string;
  url?: string;
}

const result = await client.sendMessage({
  subject:    'Hello from ssp-node',
  body:       'This message was sent programmatically.',
  recipients: [
    { id: 12345, type: 'student' },
    { id: 67890, type: 'staff'   },
  ],
});

console.log(result.success); // true
console.log(result.status);  // HTTP status code

sendMessage() — options

const ok = await client.markMessageRead(42);
console.log(ok); // true

markMessageRead() — parameters

const records = await client.getAttendance();
// Returns: AbsenceRecord[]

for (const r of records) {
  console.log(r.date);        // date string
  console.log(r.subjectName); // subject name
  console.log(r.status);      // 'present' | 'absent' | 'late' | string
  console.log(r.lessonId);    // lesson identifier
}

interface AbsenceRecord {
  id?:          string | number;
  date?:        string;
  lessonId?:    string | number;
  subjectName?: string;
  status?:      'present' | 'absent' | 'late' | string;
  [key: string]: unknown;
}

const summary = await client.getAbsenceSummary();

console.log(summary.totalLessons);    // e.g. 200
console.log(summary.totalAbsences);   // e.g. 12
console.log(summary.attendanceRate);  // e.g. 94 (percentage 0–100)

for (const sub of summary.subjects) {
  console.log(sub.subject);       // subject name
  console.log(sub.totalLessons);  // total lessons for this subject
  console.log(sub.absences);      // absences for this subject
}

interface AttendanceSummary {
  totalLessons:   number;
  totalAbsences:  number;
  attendanceRate: number;  // 0–100 percentage
  subjects: Array<{
    subject:      string;
    totalLessons: number;
    absences:     number;
  }>;
}

const grades = await client.getGrades();
// Returns: GradeEntry[]

for (const g of grades) {
  console.log(g.subjectName);  // e.g. 'Mathematics'
  console.log(g.grade);        // e.g. 'A', 'B', 'E'
  console.log(g.date);         // date the grade was set
  console.log(g.teacherName);  // grading teacher
  console.log(g.comment);      // optional comment
}

interface GradeEntry {
  id?:          string | number;
  subjectName?: string;
  activityId?:  string | number;
  grade?:       string;
  date?:        string;
  teacherName?: string;
  comment?:     string;
  [key: string]: unknown;
}

const overview = await client.getGradeOverview();
// Returns: GradeOverview[]

for (const sub of overview) {
  console.log(sub.subjectName);    // subject display name
  console.log(sub.activityId);     // activity ID
  console.log(sub.examinations);   // examination records
  console.log(sub.submissions);    // submission records
}

interface GradeOverview {
  activityId:   string;
  subjectName:  string;
  examinations: Record<string, unknown>[];
  submissions:  Record<string, unknown>[];
}

import {
  simpleLogin,
  mobileLogin,
  mobileGetSession,
  fetchMobileSession,
  mobileRefreshToken,
  verifySession,
  getSession,
  getSchools,
  getLunch,
  getSchedule,
  getAssignmentsForWeek,
  getAssignment,
  getCalendarEvents,
  getSubjects,
  getSubject,
  getNews,
  getNewsDetail,
  getStartpage,
  getClassStudents,
  getInbox,
  getOutbox,
  getMessage,
  sendMessage,
  markMessageRead,
  getAttendance,
  getAbsenceSummary,
  getGrades,
  getGradeOverview,
  isoWeek,
} from '@elias4044/ssp-node';

// ── Example: simple login + schedule ──
const school  = 'engelska';
const session = await simpleLogin(school, { username: 'john.doe', password: 'secret' });
const { lessons } = await getSchedule(school, session.cookieHeader, isoWeek(new Date()), 'my-agent/1.0');

// ── Example: mobile login ──
const tokens  = await mobileLogin(school, { username: 'john.doe', password: 'secret' });
const info    = await fetchMobileSession(school, tokens.accessToken);
const cookies = await mobileGetSession(school, tokens.accessToken, info?.userId);
const news    = await getNews(school, cookies.cookieHeader, 'my-agent/1.0');

getXxx(
  school:       string,        // school slug, e.g. 'engelska'
  cookieHeader: string,        // 'JSESSIONID=...; hash=...; usertype=1'
  ...args,                     // endpoint-specific arguments
  userAgent:    string,        // User-Agent header value
): Promise<ReturnType>

// Root-relative path — the school slug is prepended automatically
const result = await client.raw('/rest-api/student/some/endpoint', {
  method:       'GET',
  responseType: 'json',
});
console.log(result.status, result.data);

// Absolute URL — used as-is
const result2 = await client.raw<MyType>(
  'https://sms.schoolsoft.se/engelska/rest-api/student/endpoint',
  { responseType: 'json' }
);

import { schoolsoftFetch, ssUrl } from '@elias4044/ssp-node';

// ssUrl() builds a correctly structured SchoolSoft URL
const url = ssUrl('engelska', '/rest-api/student/calendar/lessons/week/22');
// → 'https://sms.schoolsoft.se/engelska/rest-api/student/calendar/lessons/week/22'

const result = await schoolsoftFetch<MyResponseType>(url, 'engelska', {
  method:       'GET',
  headers:      { Cookie: cookieHeader, Accept: 'application/json' },
  responseType: 'json',       // 'json' | 'text' | 'buffer'
  followRedirects: true,      // default true — set false to capture 302s
}, 'my-app/1.0');             // optional User-Agent

console.log(result.status);      // HTTP status code
console.log(result.data);        // parsed body (type T)
console.log(result.headers);     // lowercase key map of all response headers
console.log(result.setCookies);  // string[] — raw Set-Cookie values

import { rawRequest } from '@elias4044/ssp-node';

const raw = await rawRequest('https://sms.schoolsoft.se/engelska/rest-api/session', {
  method:          'GET',
  headers:         { Cookie: cookieHeader },
  followRedirects: false,
  responseType:    'json',
});

console.log(raw.status);     // HTTP status
console.log(raw.body);       // Buffer — parse yourself
console.log(raw.setCookies); // string[]

import { makePkcePair, makeState, base64url } from '@elias4044/ssp-node';

// Generate a PKCE verifier + SHA-256 challenge pair
const { verifier, challenge } = makePkcePair();
// verifier  — random 32-byte base64url string, kept secret on device
// challenge — SHA-256(verifier) encoded as base64url, sent to auth server

// Generate a random CSRF state token
const state = makeState();
// → 24-char hex string, e.g. 'a3f91c7e2b84d06f1234abcd'

// base64url encode arbitrary data
const encoded = base64url(Buffer.from('hello world'));

import { SchoolsoftClient } from '@elias4044/ssp-node';
import fs from 'fs';

const TOKEN_FILE = '.ssp-tokens.json';
const school = 'engelska';

async function getAuthenticatedClient(): Promise<SchoolsoftClient> {
  const client = new SchoolsoftClient({ school });

  // Try to restore saved tokens
  if (fs.existsSync(TOKEN_FILE)) {
    const saved = JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'));
    client.setAccessToken(saved.accessToken, saved.refreshToken, saved.expiresAt);

    try {
      // This auto-refreshes if access token is expired
      await client.mobileExchangeSession();

      if (await client.verifySession()) {
        console.log('Session restored from file.');
        return client;
      }
    } catch {
      console.log('Saved session invalid — re-logging in.');
    }
  }

  // Fall back to full login
  const result = await client.mobileLogin({
    username: process.env.SS_USER!,
    password: process.env.SS_PASS!,
  });

  // Persist tokens for next run
  fs.writeFileSync(TOKEN_FILE, JSON.stringify({
    accessToken:  result.accessToken,
    refreshToken: result.refreshToken,
    expiresAt:    result.expiresAt,
  }));

  await client.mobileExchangeSession();
  return client;
}

const client = await getAuthenticatedClient();
const lunch  = await client.getLunch(22);

import {
  SchoolsoftError,
  AuthenticationError,
  SessionExpiredError,
  NotFoundError,
  RateLimitError,
  NetworkError,
  ParseError,
} from '@elias4044/ssp-node';

try {
  await client.getSchedule(22);
} catch (err) {
  if (err instanceof SessionExpiredError) {
    // Session timed out — re-authenticate
    await client.login({ username, password });
  } else if (err instanceof RateLimitError) {
    const wait = err.retryAfter ?? 60;
    console.warn(`Rate limited — retry in ${wait}s`);
  } else if (err instanceof AuthenticationError) {
    console.error('Not logged in or access denied:', err.message);
  } else if (err instanceof NetworkError) {
    console.error('Network failure:', err.originalError);
  } else if (err instanceof SchoolsoftError) {
    // Catch-all for any other library error
    console.error(`[${err.statusCode}] ${err.endpoint}: ${err.message}`);
  }
}

import type {
  SchoolsoftClientOptions,
  RetryOptions,
  SimpleLoginResult,
  MobileLoginResult,
  MobileAuthFlowInit,
  MobileSessionResult,
  MobileSessionOptions,
  SessionInfo, SessionUser, SessionOrganization,
  School,
  LunchMenu, LunchDay, LunchItem,
  ScheduleLesson,
  CalendarEvent,
  Assignment, AssignmentDetail,
  Subject, SubjectEntity, SubjectDetail,
  NewsItem, NewsDetail,
  StartpageData, StartpageHomework, StartpageTest,
  ClassStudent,
  Message, MessageDetail, MessageRecipient, MessageAttachment, SendMessageOptions,
  AbsenceRecord, AttendanceSummary,
  GradeEntry, GradeOverview,
} from '@elias4044/ssp-node';

SchoolsoftClientOptions

// RetryOptions — all fields optional
interface RetryOptions {
  maxAttempts?:   number;    // total attempts including the first. Default: 3
  initialDelay?:  number;    // ms before the first retry. Default: 500
  backoffFactor?: number;    // multiplier after each attempt. Default: 2
  maxDelay?:      number;    // upper bound on delay in ms. Default: 10 000
  retryOn?:       number[];  // HTTP status codes to retry. Default: [429, 502, 503, 504]
}

const schools = await client.getSchools();
const mine = schools.find(s => s.name.toLowerCase().includes('my school name'));
console.log(mine?.id); // e.g. 'carlwahren'

const client2 = new SchoolsoftClient({ school: mine!.id });

// Main class
export { SchoolsoftClient } from './client';

// Auth helpers (functional)
export { simpleLogin } from './auth/simple';
export {
  startMobileFlow, mobileLogin, completeMobileFlow,
  mobileRefreshToken, mobileGetSession, fetchMobileSession,
  verifySession, exchangeCodeForToken,
} from './auth/mobile';

// API functions (functional)
export { getSession }                           from './api/session';
export { getSchools }                           from './api/schools';
export { getLunch }                             from './api/lunch';
export { getSchedule, isoWeek }                 from './api/schedule';
export { getAssignmentsForWeek, getAssignment } from './api/assignments';
export { getCalendarEvents }                    from './api/calendar';
export { getSubjects, getSubject }              from './api/subjects';
export { getNews }                              from './api/news';
export { getNewsDetail }                        from './api/newsdetail';
export { getStartpage }                         from './api/startpage';
export { getClassStudents }                     from './api/people';
export {
  getInbox, getOutbox, getMessage,
  sendMessage, markMessageRead,
}                                               from './api/messages';
export { getAttendance, getAbsenceSummary }     from './api/attendance';
export { getGrades, getGradeOverview }          from './api/grades';

// Utilities
export { makePkcePair, makeState, base64url }   from './utils/pkce';
export {
  schoolsoftFetch, rawRequest, ssUrl, extractCookie,
  parseCookieValue, SS_ORIGIN, DEFAULT_UA,
}                                               from './utils/http';
export { decodeLatin1, parseHtml }              from './utils/html';
export { Cache }                                from './utils/cache';
export { withRetry }                            from './utils/retry';
export {
  isoWeek as isoWeekUtil, isoYear, weekRange,
  toDateString, parseSchoolsoftDate, weekDayName,
  currentWeek, currentYear, isWeekend, schoolDays,
}                                               from './utils/date';

// Typed error classes
export {
  SchoolsoftError, AuthenticationError, SessionExpiredError,
  NotFoundError, RateLimitError, NetworkError, ParseError,
}                                               from './utils/errors';

// All types
export type {
  SchoolsoftClientOptions, RetryOptions,
  SimpleLoginResult, MobileLoginResult,
  MobileAuthFlowInit, MobileSessionResult, MobileSessionOptions,
  SessionInfo, SessionUser, SessionOrganization,
  School, LunchMenu, LunchDay, LunchItem,
  ScheduleLesson, CalendarEvent,
  Assignment, AssignmentDetail,
  Subject, SubjectEntity, SubjectDetail,
  NewsItem, NewsDetail,
  StartpageData, StartpageHomework, StartpageTest,
  ClassStudent,
  Message, MessageDetail, MessageRecipient, MessageAttachment, SendMessageOptions,
  AbsenceRecord, AttendanceSummary,
  GradeEntry, GradeOverview,
} from './types';