opensoma 0.5.1 → 0.7.0

package/src/toz-client.ts

@@ -0,0 +1,311 @@
+import {
+  assertDurationInRange,
+  buildBranchIdsParam,
+  buildStartTimeParam,
+  formatDuration,
+  formatPhone,
+  parseEmail,
+  parsePhone,
+} from './shared/utils/toz'
+import {
+  isReservationConfirmSuccess,
+  parseBookingPageBranches,
+  parseBookingPageMeetings,
+  parseMypageReservations,
+  parseTozBoothes,
+  parseTozDurations,
+  parseTozReserved,
+} from './toz-formatters'
+import { TozHttp, type TozHttpOptions } from './toz-http'
+import type { TozBooth, TozBranch, TozDuration, TozMeeting, TozReservation, TozReserved } from './types'
+
+export interface TozAvailabilityQuery {
+  date: string
+  startTime: string
+  durationMinutes: number
+  userCount: number
+  branchIds: readonly number[]
+}
+
+export interface TozCheckQuery {
+  date: string
+  startTimes: readonly string[]
+  durationMinutes: number
+  userCount: number
+  branchIds: readonly number[]
+}
+
+export interface TozCheckResult {
+  startTime: string
+  booths: TozBooth[]
+  error?: string
+}
+
+export interface TozReserveBoothArgs {
+  date: string
+  startTime: string
+  durationMinutes: number
+  userCount: number
+  boothId: number
+}
+
+export interface TozConfirmArgs {
+  reservationId: string
+  date: string
+  startTime: string
+  durationMinutes: number
+  name: string
+  phone: string
+  email: string
+  pinNum: string
+  meetingId?: number
+  newMeetingName?: string
+  memo?: string
+}
+
+export interface TozSearchArgs {
+  name?: string
+  phone?: string
+  startDate?: string
+  endDate?: string
+  meetingName?: string
+}
+
+export interface TozCancelArgs {
+  reservationId: number
+  name?: string
+  phone?: string
+}
+
+export interface TozClientOptions extends TozHttpOptions {
+  name?: string
+  phone?: string
+}
+
+export class TozClient {
+  readonly http: TozHttp
+  readonly identity: { name?: string; phone?: string }
+
+  constructor(options: TozClientOptions = {}) {
+    const { name, phone, ...httpOptions } = options
+    this.http = new TozHttp(httpOptions)
+    this.identity = { name, phone }
+  }
+
+  async branches(): Promise<TozBranch[]> {
+    await this.http.bootstrap()
+    return parseBookingPageBranches(await this.http.get('/booking.htm'))
+  }
+
+  async meetings(): Promise<TozMeeting[]> {
+    await this.http.bootstrap()
+    return parseBookingPageMeetings(await this.http.get('/booking.htm'))
+  }
+
+  async durations(date: string, startTime: string): Promise<TozDuration[]> {
+    await this.http.bootstrap()
+    const param = buildStartTimeParam(startTime)
+    const json = await this.http.postJson<unknown>('/ajaxCheckDurationTime.htm', {
+      basedate: date,
+      hour: param.slice(0, 2),
+      minute: param.slice(2, 4),
+    })
+    return parseTozDurations(json)
+  }
+
+  async available(query: TozAvailabilityQuery): Promise<TozBooth[]> {
+    assertDurationInRange(query.durationMinutes)
+    await this.http.bootstrap()
+    const json = await this.http.postJson<unknown>('/ajaxGetEnableBoothes.htm', {
+      basedate: query.date,
+      starttime: buildStartTimeParam(query.startTime),
+      durationTime: formatDuration(query.durationMinutes),
+      userCount: String(query.userCount),
+      branchIds: buildBranchIdsParam(query.branchIds),
+    })
+    return parseTozBoothes(json)
+  }
+
+  async check(query: TozCheckQuery): Promise<TozCheckResult[]> {
+    if (query.startTimes.length === 0) {
+      throw new Error('toz check requires at least one --time. For a single slot, use `toz available` instead.')
+    }
+    if (query.startTimes.length > 6) {
+      throw new Error(
+        'Too many times (max 6 per invocation). Consider `toz available` for a single slot, or split into multiple invocations.',
+      )
+    }
+    assertDurationInRange(query.durationMinutes)
+    await this.http.bootstrap()
+
+    const results: TozCheckResult[] = []
+    for (let i = 0; i < query.startTimes.length; i += 1) {
+      const startTime = query.startTimes[i]!
+      try {
+        const booths = await this.available({
+          date: query.date,
+          startTime,
+          durationMinutes: query.durationMinutes,
+          userCount: query.userCount,
+          branchIds: query.branchIds,
+        })
+        results.push({ startTime, booths })
+      } catch (error) {
+        results.push({
+          startTime,
+          booths: [],
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+      if (i < query.startTimes.length - 1) await sleep(500)
+    }
+    return results
+  }
+
+  async reserveBooth(args: TozReserveBoothArgs): Promise<TozReserved> {
+    assertDurationInRange(args.durationMinutes)
+    await this.http.bootstrap()
+    const json = await this.http.postJson<unknown>('/ajaxReservationBooth.htm', {
+      basedate: args.date,
+      starttime: buildStartTimeParam(args.startTime),
+      durationTime: formatDuration(args.durationMinutes),
+      userCount: String(args.userCount),
+      booth_id: String(args.boothId),
+    })
+    const reserved = parseTozReserved(json)
+    if (reserved.isLargeBooth) {
+      throw new Error('대형부스 예약은 선입금 약관 동의가 필요합니다. v1에서는 지원하지 않습니다 (small booths only).')
+    }
+    return reserved
+  }
+
+  async skipEquipment(args: {
+    reservationId: string
+    date: string
+    startTime: string
+    durationMinutes: number
+  }): Promise<void> {
+    await this.http.postText('/ajaxReservationEquipment.htm', {
+      reservationId: args.reservationId,
+      basedate: args.date,
+      starttime: buildStartTimeParam(args.startTime),
+      durationTime: formatDuration(args.durationMinutes),
+      equipmentNotebookChecked: 'false',
+      equipmentProjectorChecked: 'false',
+      equipmentMonitorChecked: 'false',
+      equipmentPlayerChecked: 'false',
+      equipmentSpeakerChecked: 'false',
+      equipmentNotebookCnt: '0',
+      equipmentProjectorCnt: '0',
+      equipmentMonitorCnt: '0',
+      equipmentPlayerCnt: '0',
+      equipmentSpeakerCnt: '0',
+    })
+  }
+
+  async sendOtp(phone?: string): Promise<void> {
+    const parts = parsePhone(this.requirePhone(phone))
+    const result = await this.http.postText('/ajaxHpVerify.htm', { ...parts })
+    if (result !== 'SUCCESS') {
+      throw new Error(`OTP 발송 실패: ${result}`)
+    }
+  }
+
+  async confirm(args: TozConfirmArgs): Promise<{ resultMsg: string; isLargeBooth: boolean }> {
+    if (!args.meetingId && !args.newMeetingName) {
+      throw new Error('meetingId 또는 newMeetingName 중 하나는 필수입니다.')
+    }
+    const phoneParts = parsePhone(args.phone)
+    const emailParts = parseEmail(args.email)
+
+    const json = await this.http.postJson<{ resultMsg?: string; message3?: string | null }>(
+      '/ajaxReservationConfirm.htm',
+      {
+        reservationId: args.reservationId,
+        phone: formatPhone(phoneParts),
+        ...phoneParts,
+        name: args.name,
+        pinNum: args.pinNum,
+        ...emailParts,
+        meeting_id: args.meetingId ? String(args.meetingId) : '새모임',
+        newMeetingName: args.newMeetingName ?? '',
+        prepareMemo: args.memo ?? '',
+        projectSeq: '',
+        tozApplyType: '',
+        addedInfo: '',
+        attendType: '',
+        isMobile: 'false',
+      },
+    )
+
+    const resultMsg = json.resultMsg ?? ''
+    if (!isReservationConfirmSuccess(resultMsg)) {
+      throw new Error(resultMsg || '예약 확정에 실패했습니다.')
+    }
+    return { resultMsg, isLargeBooth: resultMsg.includes('대형부스') }
+  }
+
+  async destroyHold(): Promise<void> {
+    await this.http.postText('/ajaxDestroyReservation.htm', {})
+  }
+
+  async myReservations(args: TozSearchArgs = {}): Promise<TozReservation[]> {
+    await this.http.bootstrap()
+    await this.mypageLogin(this.requireName(args.name), this.requirePhone(args.phone))
+
+    const html = await this.http.post('/mypage.htm', {
+      opage: '1',
+      rpage: '1',
+      key: '',
+      projectSeq: '',
+      tozApplyType: '',
+      addedInfo: '',
+      startdate: args.startDate ?? '',
+      enddate: args.endDate ?? '',
+      meetingName: args.meetingName ?? '',
+    })
+    return parseMypageReservations(html)
+  }
+
+  async cancel(args: TozCancelArgs): Promise<void> {
+    await this.http.bootstrap()
+    await this.mypageLogin(this.requireName(args.name), this.requirePhone(args.phone))
+
+    const result = await this.http.postText('/ajaxCancelReservation.htm', {
+      reservation_id: String(args.reservationId),
+    })
+    if (result !== 'SUCCESS') {
+      if (result === 'FAILED') throw new Error('취소하지 못했습니다.')
+      throw new Error(result || '취소하지 못했습니다.')
+    }
+  }
+
+  private requireName(name: string | undefined): string {
+    const resolved = name ?? this.identity.name
+    if (!resolved) throw new Error('Toz name is required (pass via args or TozClient({ name }))')
+    return resolved
+  }
+
+  private requirePhone(phone: string | undefined): string {
+    const resolved = phone ?? this.identity.phone
+    if (!resolved) throw new Error('Toz phone is required (pass via args or TozClient({ phone }))')
+    return resolved
+  }
+
+  private async mypageLogin(name: string, phone: string): Promise<void> {
+    const parts = parsePhone(phone)
+    await this.http.post('/mypage_login_.htm', {
+      key: '',
+      projectSeq: '',
+      tozApplyType: '',
+      addedInfo: '',
+      email: '',
+      name,
+      ...parts,
+    })
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/toz-pending-store.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { mkdtempSync } from 'node:fs'
+import { readdir, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { TozPendingStore, type TozPendingReservation } from './toz-pending-store'
+
+let configDir: string
+const cleanups: (() => void)[] = []
+
+function freshStore(): TozPendingStore {
+  configDir = mkdtempSync(join(tmpdir(), 'toz-pending-'))
+  cleanups.push(() => {
+    require('node:fs').rmSync(configDir, { recursive: true, force: true })
+  })
+  return new TozPendingStore(configDir)
+}
+
+afterEach(() => {
+  while (cleanups.length > 0) cleanups.pop()?.()
+})
+
+const sample: TozPendingReservation = {
+  reservationId: 'abc-123',
+  cookies: { JSESSIONID: 'XYZ' },
+  branchName: '토즈타워점',
+  branchTel: '02-3454-0116',
+  boothGroupName: '2인부스 A타입',
+  isLargeBooth: false,
+  date: '2026-04-21',
+  startTime: '14:00',
+  endTime: '16:00',
+  durationMinutes: 120,
+  userCount: 2,
+  boothId: 740,
+  meetingId: 2305094,
+  email: 'me@gmail.com',
+  name: '홍길동',
+  phone: '010-1234-5678',
+  createdAt: '2026-04-17T18:42:13.291Z',
+  expiresAt: '2026-04-17T18:47:13.291Z',
+}
+
+describe('TozPendingStore', () => {
+  test('returns null when no pending file exists', async () => {
+    const store = freshStore()
+    expect(await store.get()).toBeNull()
+  })
+
+  test('round-trips a reservation through set/get', async () => {
+    const store = freshStore()
+    await store.set(sample)
+    expect(await store.get()).toEqual(sample)
+  })
+
+  test('clear removes the file', async () => {
+    const store = freshStore()
+    await store.set(sample)
+    await store.clear()
+    expect(await store.get()).toBeNull()
+  })
+
+  test('clear is no-op when file does not exist', async () => {
+    const store = freshStore()
+    await store.clear()
+    expect(await store.get()).toBeNull()
+  })
+
+  test('overwrites an existing reservation', async () => {
+    const store = freshStore()
+    await store.set(sample)
+    const updated = { ...sample, reservationId: 'new-id' }
+    await store.set(updated)
+    expect(await store.get()).toEqual(updated)
+  })
+
+  test('writes file with 0o600 permissions at creation (no widened window)', async () => {
+    const store = freshStore()
+    await store.set(sample)
+    const fileStat = await stat(join(configDir, 'toz-pending.json'))
+    expect(fileStat.mode & 0o777).toBe(0o600)
+  })
+
+  test('leaves no temp file behind after set', async () => {
+    const store = freshStore()
+    await store.set(sample)
+    const entries = await readdir(configDir)
+    expect(entries).toEqual(['toz-pending.json'])
+  })
+})

package/src/toz-pending-store.ts

@@ -0,0 +1,62 @@
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+export interface TozPendingReservation {
+  reservationId: string
+  cookies: Record<string, string>
+  branchName: string
+  branchTel: string
+  boothGroupName: string
+  isLargeBooth: boolean
+  date: string
+  startTime: string
+  endTime: string
+  durationMinutes: number
+  userCount: number
+  boothId: number
+  meetingId?: number
+  newMeetingName?: string
+  email: string
+  memo?: string
+  name: string
+  phone: string
+  createdAt: string
+  expiresAt: string
+}
+
+export class TozPendingStore {
+  private readonly path: string
+
+  constructor(configDir?: string) {
+    const dir = configDir ?? join(homedir(), '.config', 'opensoma')
+    this.path = join(dir, 'toz-pending.json')
+  }
+
+  async get(): Promise<TozPendingReservation | null> {
+    if (!existsSync(this.path)) return null
+
+    try {
+      const raw = await readFile(this.path, 'utf8')
+      return JSON.parse(raw) as TozPendingReservation
+    } catch {
+      return null
+    }
+  }
+
+  async set(reservation: TozPendingReservation): Promise<void> {
+    const dir = dirname(this.path)
+    await mkdir(dir, { recursive: true })
+    // Write to a temp file with 0o600 from creation, then rename atomically.
+    // Avoids the default 0o644 window between writeFile() and chmod() that
+    // would briefly expose the cookie + phone number to other users on the system.
+    const tmp = `${this.path}.tmp-${process.pid}-${Date.now()}`
+    await writeFile(tmp, JSON.stringify(reservation, null, 2), { mode: 0o600 })
+    await rename(tmp, this.path)
+  }
+
+  async clear(): Promise<void> {
+    await rm(this.path, { force: true })
+  }
+}

package/src/types.test.ts

@@ -5,7 +5,6 @@ import {
   ApprovalListItemSchema,
   CredentialsSchema,
   DashboardSchema,
-  EventListItemSchema,
   MemberInfoSchema,
   MentoringDetailSchema,
   MentoringListItemSchema,
@@ -16,6 +15,7 @@ import {
   ReportDetailSchema,
   ReportListItemSchema,
   RoomCardSchema,
+  ScheduleListItemSchema,
   TeamInfoSchema,
 } from './types'
 
@@ -79,6 +79,7 @@ describe('schemas', () => {
       organization: 'Indent',
       position: '',
       team: { name: '오픈소마', members: '전수열, 김개발', mentor: '전수열' },
+      teams: [],
       mentoringSessions: [{ title: 'AI 멘토링', url: '/mentoring/1', status: '접수중' }],
       roomReservations: [{ title: 'A1 회의', url: '/room/1', status: '예약완료' }],
     }
@@ -109,8 +110,23 @@ describe('schemas', () => {
   it('preserves valid TeamInfo values through parse', () => {
     const input = {
       teams: [
-        { name: '오픈소마', memberCount: 3, joinStatus: '참여중' },
-        { name: '김앤강', memberCount: 5, joinStatus: '참여하기' },
+        {
+          name: '오픈소마',
+          projectName: 'Previzion',
+          ownerId: 'owner-1',
+          teamId: 'team-a',
+          leader: '전수열',
+          members: [
+            { name: '전수열', userId: 'uid-1' },
+            { name: '강동우', userId: 'uid-2' },
+          ],
+          mentors: [{ name: '문승현', userId: 'uid-m1' }],
+          ictCategoryMajor: 'SW·SI',
+          ictCategoryMinor: '응용SW',
+          teamCompleted: true,
+          mentorCompleted: false,
+          joinStatus: '완료',
+        },
       ],
       currentTeams: 1,
       maxTeams: 100,
@@ -131,17 +147,14 @@ describe('schemas', () => {
     expect(MemberInfoSchema.parse(input)).toEqual(input)
   })
 
-  it('preserves valid EventListItem values through parse', () => {
+  it('preserves valid ScheduleListItem values through parse', () => {
     const input = {
-      id: 11,
-      category: '행사',
-      title: '데모데이',
-      registrationPeriod: { start: '2026-04-01', end: '2026-04-05' },
-      eventPeriod: { start: '2026-04-10', end: '2026-04-10' },
-      status: '접수중',
-      createdAt: '2026-03-30',
+      id: 1,
+      category: '교육',
+      title: '[교육] 디자인씽킹 교육',
+      period: { start: '2026-04-21', end: '2026-04-26' },
     }
-    expect(EventListItemSchema.parse(input)).toEqual(input)
+    expect(ScheduleListItemSchema.parse(input)).toEqual(input)
   })
 
   it('preserves valid ApplicationHistoryItem values through parse', () => {
@@ -266,7 +279,7 @@ describe('schemas', () => {
     ).toThrow()
     expect(() => TeamInfoSchema.parse({ teams: [{ name: '김개발' }], currentTeams: 1, maxTeams: 100 })).toThrow()
     expect(() => MemberInfoSchema.parse({ email: 1, name: '전수열' })).toThrow()
-    expect(() => EventListItemSchema.parse({ id: 1, title: '행사', status: '접수중' })).toThrow()
+    expect(() => ScheduleListItemSchema.parse({ id: 1, category: '교육', title: '강의' })).toThrow()
     expect(() => ApplicationHistoryItemSchema.parse({ id: 1, status: '신청완료' })).toThrow()
     expect(() => PaginationSchema.parse({ total: '23', currentPage: 2, totalPages: 3 })).toThrow()
     expect(() => CredentialsSchema.parse({ sessionCookie: 'cookie' })).toThrow()

package/src/types.ts

@@ -18,9 +18,22 @@ const DashboardStatusItemSchema = z.object({
   venue: z.string().optional(),
   type: z.enum(['자유 멘토링', '멘토 특강']).optional(),
 })
+const TeamMemberSchema = z.object({
+  name: z.string(),
+  userId: z.string(),
+})
 const TeamListItemSchema = z.object({
   name: z.string(),
-  memberCount: z.number(),
+  projectName: z.string(),
+  ownerId: z.string(),
+  teamId: z.string(),
+  leader: z.string(),
+  members: z.array(TeamMemberSchema),
+  mentors: z.array(TeamMemberSchema),
+  ictCategoryMajor: z.string(),
+  ictCategoryMinor: z.string(),
+  teamCompleted: z.boolean(),
+  mentorCompleted: z.boolean(),
   joinStatus: z.string(),
 })
 
@@ -54,6 +67,23 @@ export const MentoringDetailSchema = MentoringListItemSchema.extend({
 })
 export type MentoringDetail = z.infer<typeof MentoringDetailSchema>
 
+export const MentoringEditFormSchema = z.object({
+  id: z.number(),
+  title: z.string(),
+  reportCd: z.string(),
+  receiptType: z.enum(['UNTIL_LECTURE', 'DIRECT']),
+  bgndeDate: z.string(),
+  bgndeTime: z.string(),
+  enddeDate: z.string(),
+  enddeTime: z.string(),
+  eventDt: z.string(),
+  eventStime: z.string(),
+  eventEtime: z.string(),
+  applyCnt: z.number(),
+  place: z.string(),
+})
+export type MentoringEditForm = z.infer<typeof MentoringEditFormSchema>
+
 export const RoomCardSchema = z.object({
   itemId: z.number(),
   name: z.string(),
@@ -64,11 +94,55 @@ export const RoomCardSchema = z.object({
 })
 export type RoomCard = z.infer<typeof RoomCardSchema>
 
+export const RoomReservationStatusSchema = z.enum(['confirmed', 'cancelled', 'unknown'])
+export type RoomReservationStatus = z.infer<typeof RoomReservationStatusSchema>
+
+export const RoomReservationDetailSchema = z.object({
+  rentId: z.number(),
+  itemId: z.number(),
+  title: z.string(),
+  date: z.string(),
+  startTime: z.string(),
+  endTime: z.string(),
+  attendees: z.number(),
+  notes: z.string(),
+  status: RoomReservationStatusSchema,
+  statusCode: z.string(),
+})
+export type RoomReservationDetail = z.infer<typeof RoomReservationDetailSchema>
+
+export const RoomReservationListItemSchema = z.object({
+  rentId: z.number(),
+  venue: z.string(),
+  title: z.string(),
+  date: z.string(),
+  startTime: z.string(),
+  endTime: z.string(),
+  author: z.string(),
+  status: RoomReservationStatusSchema,
+  statusLabel: z.string(),
+  registeredAt: z.string(),
+})
+export type RoomReservationListItem = z.infer<typeof RoomReservationListItemSchema>
+
+export const RoomUpdateOptionsSchema = z.object({
+  title: z.string().optional(),
+  roomId: z.number().optional(),
+  date: z.string().optional(),
+  slots: z.array(z.string()).optional(),
+  attendees: z.number().optional(),
+  notes: z.string().optional(),
+})
+export type RoomUpdateOptions = z.infer<typeof RoomUpdateOptionsSchema>
+
 export const DashboardSchema = z.object({
   name: z.string(),
   role: z.string(),
   organization: z.string(),
   position: z.string(),
+  // Mirrors the single team the native dashboard HTML renders in `ul.dash-box`.
+  // The native page only ever surfaces one team here even when the user belongs
+  // to multiple. For the full set, see `teams` below.
   team: z
     .object({
       name: z.string(),
@@ -76,6 +150,9 @@ export const DashboardSchema = z.object({
       mentor: z.string(),
     })
     .optional(),
+  // Enriched from `team.list()` so consumers see every team the user belongs to,
+  // not just the one the native dashboard chose to render.
+  teams: z.array(TeamListItemSchema),
   mentoringSessions: z.array(DashboardStatusItemSchema),
   roomReservations: z.array(DashboardStatusItemSchema),
 })
@@ -94,6 +171,8 @@ export const NoticeDetailSchema = NoticeListItemSchema.extend({
 })
 export type NoticeDetail = z.infer<typeof NoticeDetailSchema>
 
+export type TeamMember = z.infer<typeof TeamMemberSchema>
+export type TeamListItem = z.infer<typeof TeamListItemSchema>
 export const TeamInfoSchema = z.object({
   teams: z.array(TeamListItemSchema),
   currentTeams: z.number(),
@@ -112,21 +191,19 @@ export const MemberInfoSchema = z.object({
 })
 export type MemberInfo = z.infer<typeof MemberInfoSchema>
 
-export const EventListItemSchema = z.object({
+export const ScheduleListItemSchema = z.object({
   id: z.number(),
   category: z.string(),
   title: z.string(),
-  registrationPeriod: DateRangeSchema,
-  eventPeriod: DateRangeSchema,
-  status: z.string(),
-  createdAt: z.string(),
+  period: DateRangeSchema,
 })
-export type EventListItem = z.infer<typeof EventListItemSchema>
+export type ScheduleListItem = z.infer<typeof ScheduleListItemSchema>
 
 export const ApplicationHistoryItemSchema = z.object({
   id: z.number(),
   category: z.string(),
   title: z.string(),
+  url: z.string().optional(),
   author: z.string(),
   sessionDate: z.string(),
   appliedAt: z.string(),
@@ -294,8 +371,11 @@ export const MentoringCreateOptionsSchema = z.object({
   endTime: z.string(),
   venue: z.string(),
   maxAttendees: z.number().optional(),
+  receiptType: z.enum(['UNTIL_LECTURE', 'DIRECT']).optional(),
   regStart: z.string().optional(),
+  regStartTime: z.string().optional(),
   regEnd: z.string().optional(),
+  regEndTime: z.string().optional(),
   content: z.string().optional(),
 })
 export type MentoringCreateOptions = z.infer<typeof MentoringCreateOptionsSchema>