API Client

import { ExodeAPI } from '@exode-team/sdk/api'

const exodeApi = new ExodeAPI({
  sellerId: Number(process.env.EXODE_SELLER_ID),
  schoolId: Number(process.env.EXODE_SCHOOL_ID),
  token: process.env.EXODE_TOKEN!,
  baseUrl: 'https://api.exode.biz/saas/v2', // default
  timeout: 30_000,                           // default 30s
})

import { ProfileRole, UserStateKey, UserStatus } from '@exode-team/sdk/api'

// Create — returns the user object (or null)
const user = await exodeApi.school.user.create({
  email: '[email protected]',
  profile: { firstName: 'John', role: ProfileRole.Student },
})

if (!user) throw new Error('User was not created')

// Update — returns the user
await exodeApi.school.user.update(user.id, { profile: { lastName: 'Smith' } })

// Update by external id (extId from your CRM/LMS)
await exodeApi.school.user.updateByExtId('crm_12345', { profile: { lastName: 'Smith' } })

// Upsert (create or update by email/phone/tgId/extId)
const { user: u, isCreated } = await exodeApi.school.user.upsert({
  email: '[email protected]',
  profile: { firstName: 'John' },
})

// Find — exactly one of login | tgId | extId; returns the user or null
const found = await exodeApi.school.user.find({ login: '[email protected]' })

// Find many — lists of logins / tgIds / extIds (≤250 each); not found ones are omitted
const users = await exodeApi.school.user.findMany({ extIds: ['crm_12345', 'crm_67890'] })

// List — filter (statuses/search/extIds/date ranges) + sort + pagination
const { items } = await exodeApi.school.user.list({
  statuses: [UserStatus.Active, UserStatus.OnLeave],
  take: 50,
})

// Ban / unban — via status (the `banned` flag was removed from the API)
await exodeApi.school.user.update(user.id, { status: UserStatus.Banned })
await exodeApi.school.user.update(user.id, { status: UserStatus.Active }) // the actual status is recalculated automatically

// Delete (≤250 at a time) — { deleted, skipped }
const { deleted, skipped } = await exodeApi.school.user.deleteMany([1, 2, 3], 'Access revocation')

// State — key from the UserStateKey enum
await exodeApi.school.user.setState(user.id, UserStateKey.OnBoardingProgress, { step: 2 }) // → boolean
const value = await exodeApi.school.user.getState(user.id, UserStateKey.OnBoardingProgress) // → unknown

// Auto-auth token — { session, isCreated }
const { session } = await exodeApi.school.user.createAuthToken({ userId: user.id })
// session.token → put into ?___uat=<token> for auto-login

import { AbsenceType, EmploymentType } from '@exode-team/sdk/api'

const tree = await exodeApi.school.staff.department.tree()

const department = await exodeApi.school.staff.department.create({ name: 'Engineering', extId: 'dep_engineering' })
const position = await exodeApi.school.staff.position.create({ name: 'Backend Developer' })

const employment = await exodeApi.school.staff.employment.hire({
  userId: 123,
  departmentId: department.id,
  positionId: position.id,
  type: EmploymentType.FullTime,
})

await exodeApi.school.staff.departmentManager.set({ departmentId: department.id, employmentId: employment.id })

await exodeApi.school.staff.absence.create({
  employmentId: employment.id,
  type: AbsenceType.Vacation,
  startAt: '2026-08-01',
})

// List groups (filter + pagination)
const { items } = await exodeApi.school.group.list({ courseIds: [10], take: 50 })

// List group members (filter + pagination)
const members = await exodeApi.school.group.listMembers({ groupIds: [42], active: true, take: 100 })

// Add members (≤250) — { exist, created }
await exodeApi.school.group.addMembers(groupId, [1, 2, 3])

// Remove members (≤250) — { affected }
await exodeApi.school.group.removeMembers(groupId, [1])

import { CourseType } from '@exode-team/sdk/api'

// List courses
const { items } = await exodeApi.school.course.list({ types: [CourseType.VideoCourse], take: 20 })

// Course members' progress (pagination)
const progress = await exodeApi.school.course.progresses(courseId, { take: 100 })

const { items } = await exodeApi.school.certificate.list({
  courseIds: [10],
  issuedAtDateRange: { from: '2026-01-01' },
  take: 50,
})

const { items } = await exodeApi.school.productAccess.list({ active: true, take: 50 })

import { InvoiceType } from '@exode-team/sdk/api'

const { items } = await exodeApi.school.invoice.list({ types: [InvoiceType.Regular], take: 50 })

import { FormLayoutMode, FormLayoutStatus } from '@exode-team/sdk/api'

// Form layouts
const { items: layouts } = await exodeApi.school.form.layoutList({ modes: [FormLayoutMode.Signup], take: 20 })
const layout = await exodeApi.school.form.layoutCreate({ mode: FormLayoutMode.Custom, name: 'Survey', internalName: 'survey' })
await exodeApi.school.form.layoutUpdate(layout.id, { status: FormLayoutStatus.Published })
await exodeApi.school.form.layoutDelete(layout.id) // → { affected }

// Custom field values
const { items } = await exodeApi.school.form.customFieldValueGet({ userIds: [27], take: 50 })

// Set values by slug (type is inferred automatically)
await exodeApi.school.form.customFieldValueSetBySlug({
  userId: 27,
  layoutId: layout.id,
  values: [{ slug: 'city', value: 'Tashkent' }, { slug: 'age', value: 25 }],
})

// Set values by fieldId (typed)
await exodeApi.school.form.customFieldValueSet({
  userId: 27,
  layoutId: layout.id,
  values: [{ fieldId: 10, text: 'Tashkent' }],
})

import { QueryExportType, QueryExportFormat, WorkflowExecutionStatus } from '@exode-team/sdk/api'

// 1. Start — returns { uuid, status, ... }
const { uuid } = await exodeApi.school.queryExport.generate({
  type: QueryExportType.GroupMemberFindMany,
  format: QueryExportFormat.Csv,
  variables: { filter: { groupIds: [42] } },
})

// 2. Poll for result (repeat until status becomes Completed/Failed; null — not found yet)
const result = await exodeApi.school.queryExport.getResult(uuid)

if (result?.status === WorkflowExecutionStatus.Completed) {
  // `result.result` is typed as unknown — cast it to the documented shape
  const file = result.result as { fileUrl: string; fileName: string; fileSize: number }

  console.log('File:', file.fileUrl)
}

import type { User, ListGroupOutput } from '@exode-team/sdk/api'

import { ExodeAPI, ExodeAPIError } from '@exode-team/sdk/api'

try {
  await exodeApi.school.user.create({ email: '[email protected]' })
} catch (error) {
  if (error instanceof ExodeAPIError) {
    console.error(error.code)        // 400, 401, 403, 408, 429, 0 (network)...
    console.error(error.errorCause)  // 'EmailIsBusy', 'Unauthorized', 'Timeout', 'NetworkError'...
    console.error(error.details)     // technical description (optional)
  }
}