nurekit/dist/index.ts

Node.js client for Mindenit Schedule API

//#region src/types/index.d.ts
type EventType = "Лк" | "Пз" | "Лб" | "Конс" | "Зал" | "Екз" | "КП/КР";
interface Group {
  id: number;
  name: string;
}
interface Auditorium extends Group {}
interface Teacher {
  id: number;
  fullName: string;
  shortName: string;
}
interface Subject {
  id: number;
  brief: string;
  title: string;
}
interface Schedule {
  id: number;
  startedAt: number;
  endedAt: number;
  auditorium: Auditorium;
  numberPair: number;
  type: string;
  groups: Group[];
  teachers: Teacher[];
  subject: Subject;
  pairIndex: number;
  pairsCount: number;
}
interface GroupScheduleFilters {
  lessonTypes: EventType[];
  teachers: number[];
  auditoriums: number[];
  subjects: number[];
}
interface TeacherScheduleFilters {
  lessonTypes: EventType[];
  groups: number[];
  auditoriums: number[];
  subjects: number[];
}
interface AuditoriumScheduleFilters {
  lessonTypes: EventType[];
  groups: number[];
  teachers: number[];
  subjects: number[];
}
interface GetScheduleParams<TFilters extends object> {
  id: number;
  startedAt: number;
  endedAt: number;
  filters?: Partial<TFilters>;
}
type ScheduleType = "groups" | "auditoriums" | "teachers";
interface ShortSchedule {
  name: string;
  id: number;
  type: ScheduleType;
}
interface ScheduleQueryParams {
  start: number;
  end: number;
  filters?: Record<string, unknown>;
}
interface Link {
  id: string;
  label: string;
  url: string;
  type: EventType;
  subjectId: number;
  userId: string;
}
type CreateLink = Pick<Link, "label" | "url" | "type" | "subjectId">;
type UpdateLink = Pick<Link, "label" | "url">;
interface SharableLink {
  id: string;
  links: Link[];
}
interface CreateSharableLink {
  linkIds: string[];
}
//#endregion
//#region src/types/modules.d.ts
interface BaseModule<TEntity extends object, TFilters extends object> {
  findMany: () => Promise<TEntity[]>;
  getSchedule: (params: GetScheduleParams<TFilters>) => Promise<Schedule[]>;
}
interface AuditoriumsModule extends BaseModule<Auditorium, AuditoriumScheduleFilters> {
  getGroups: (auditoriumId: number) => Promise<Group[]>;
  getTeachers: (auditoriumId: number) => Promise<Teacher[]>;
  getSubjects: (auditoriumId: number) => Promise<Subject[]>;
}
interface GroupsModule extends BaseModule<Group, GroupScheduleFilters> {
  getAuditoriums: (groupId: number) => Promise<Auditorium[]>;
  getTeachers: (groupId: number) => Promise<Teacher[]>;
  getSubjects: (groupId: number) => Promise<Subject[]>;
}
interface TeachersModule extends BaseModule<Teacher, TeacherScheduleFilters> {
  getAuditoriums: (teacherId: number) => Promise<Auditorium[]>;
  getGroups: (teacherId: number) => Promise<Group[]>;
  getSubjects: (teacherId: number) => Promise<Subject[]>;
}
interface LinksModule {
  getUserLinks: () => Promise<Link[]>;
  createLink: (data: CreateLink) => Promise<Link>;
  updateLink: (linkId: string, data: UpdateLink) => Promise<Link>;
  deleteLink: (linkId: string) => Promise<Link>;
}
interface SharableLinksModule {
  getLink: (linkId: string) => Promise<SharableLink>;
  createLink: (data: CreateSharableLink) => Promise<{
    id: string;
  }>;
  acceptLink: (linkId: string) => Promise<void>;
}
//#endregion
//#region src/client.d.ts
declare class Nurekit {
  readonly auditoriums: AuditoriumsModule;
  readonly groups: GroupsModule;
  readonly teachers: TeachersModule;
  readonly links: LinksModule;
  readonly sharableLinks: SharableLinksModule;
  constructor(baseUrl?: string);
}
//#endregion
//#region src/errors.d.ts
declare class NurekitError extends Error {
  status: number;
  constructor(message?: string, status?: number);
}
//#endregion
export { type Auditorium, type AuditoriumScheduleFilters, type CreateLink, type CreateSharableLink, type EventType, type GetScheduleParams, type Group, type GroupScheduleFilters, type Link, Nurekit, NurekitError, type Schedule, type ScheduleQueryParams, type SharableLink, type ShortSchedule, type Subject, type Teacher, type TeacherScheduleFilters, type UpdateLink };