@proteos/sdk 0.53.0 → 0.54.0

package/src/scheduling/index.ts

@@ -0,0 +1,576 @@
+import type { ProteosClient } from '../client.js'
+import type {
+  AvailabilityConstraint,
+  BookSchedulingLinkRequest,
+  BookSchedulingLinkResponse,
+  Calendar,
+  CalendarConnection,
+  CalendarEvent,
+  CalendarEventType,
+  CalendarEventsResponse,
+  CreateAvailabilityConstraintRequest,
+  CreateCalendarConnectionRequest,
+  CreateCalendarEventRequest,
+  CreateSchedulingLinkRequest,
+  CancelPublicCalendarEventRequest,
+  GetPublicSlotsQuery,
+  GetSlotsRequest,
+  GetSlotsResponse,
+  ListAvailabilityConstraintsQuery,
+  ListCalendarConnectionsQuery,
+  ListCalendarEventTypesQuery,
+  ListCalendarEventsQuery,
+  ListCalendarsQuery,
+  ListResponse,
+  ListSchedulingLinksQuery,
+  PublicBookSchedulingLinkResponse,
+  PublicCalendarEvent,
+  PublicSchedulingLink,
+  PutCalendarEventTypeRequest,
+  PutSchedulingProfileRequest,
+  RecurrenceScope,
+  ReschedulePublicCalendarEventRequest,
+  RespondCalendarEventRequest,
+  SchedulingLink,
+  SchedulingProfile,
+  UpdateCalendarSyncRequest,
+  UpdateAvailabilityConstraintRequest,
+  UpdateCalendarConnectionRequest,
+  UpdateCalendarEventRequest,
+  UpdateCalendarEventTypeRequest,
+  UpdateCalendarRequest,
+  UpdateSchedulingLinkRequest,
+} from './types.js'
+
+export * from './types.js'
+
+const SCHEDULING_BASE_PATH = '/scheduling/v1'
+
+const encode = encodeURIComponent
+
+/**
+ * Facade for scheduling-service: calendar connections (bindings to
+ * connector-service google-calendar / microsoft-calendar grants), the
+ * calendars under them with their platform roles, per-user scheduling
+ * profiles, and the two-way calendar_event mirror.
+ *
+ * `*Mine` methods act on the caller's own rows (`/me/...`); `*ForUser`
+ * methods are the admin path (`/users/:userId/...`).
+ *
+ * ```ts
+ * const scheduling = new SchedulingClient(client)
+ * const connection = await scheduling.calendarConnections.connect({ connection_id })
+ * const { data: calendars } = await scheduling.calendars.listMine()
+ * await scheduling.calendars.updateMine(calendars[0].id, { is_synced: true })
+ * const { data: events } = await scheduling.calendarEvents.list({ from, to })
+ * ```
+ */
+export class SchedulingClient {
+  readonly calendarConnections: CalendarConnectionService
+  readonly calendars: CalendarService
+  readonly schedulingProfiles: SchedulingProfileService
+  readonly calendarEvents: CalendarEventService
+  readonly calendarEventTypes: CalendarEventTypeService
+  readonly availabilityConstraints: AvailabilityConstraintService
+  readonly slots: SlotService
+  readonly schedulingLinks: SchedulingLinkService
+  /** The unauthenticated scheduling page + manage page (no Authorization header). */
+  readonly public: PublicSchedulingService
+
+  constructor(client: ProteosClient) {
+    this.schedulingLinks = new SchedulingLinkServiceImpl(client)
+    this.public = new PublicSchedulingServiceImpl(client)
+    this.calendarConnections = new CalendarConnectionServiceImpl(client)
+    this.calendars = new CalendarServiceImpl(client)
+    this.schedulingProfiles = new SchedulingProfileServiceImpl(client)
+    this.calendarEvents = new CalendarEventServiceImpl(client)
+    this.calendarEventTypes = new CalendarEventTypeServiceImpl(client)
+    this.availabilityConstraints = new AvailabilityConstraintServiceImpl(client)
+    this.slots = new SlotServiceImpl(client)
+  }
+}
+
+/** Bindings to connector-service calendar grants. */
+export interface CalendarConnectionService {
+  listMine(query?: ListCalendarConnectionsQuery): Promise<ListResponse<CalendarConnection>>
+  /** Bind one of the caller's user-scope calendar connector connections; discovers its calendars. */
+  connect(request: CreateCalendarConnectionRequest): Promise<CalendarConnection>
+  updateMine(id: string, request: UpdateCalendarConnectionRequest): Promise<CalendarConnection>
+  disconnectMine(id: string): Promise<void>
+  /** Enqueue a sync of every synced calendar under the connection. */
+  syncMine(id: string, request?: UpdateCalendarSyncRequest): Promise<CalendarConnection>
+  listForUser(
+    userId: string,
+    query?: ListCalendarConnectionsQuery,
+  ): Promise<ListResponse<CalendarConnection>>
+  updateForUser(
+    userId: string,
+    id: string,
+    request: UpdateCalendarConnectionRequest,
+  ): Promise<CalendarConnection>
+  disconnectForUser(userId: string, id: string): Promise<void>
+}
+
+class CalendarConnectionServiceImpl implements CalendarConnectionService {
+  constructor(private readonly client: ProteosClient) {}
+
+  listMine(query: ListCalendarConnectionsQuery = {}): Promise<ListResponse<CalendarConnection>> {
+    return this.client.requestWithQuery(
+      'GET',
+      `${SCHEDULING_BASE_PATH}/me/calendar-connections`,
+      query,
+    )
+  }
+
+  connect(request: CreateCalendarConnectionRequest): Promise<CalendarConnection> {
+    return this.client.request('POST', `${SCHEDULING_BASE_PATH}/me/calendar-connections`, request)
+  }
+
+  updateMine(id: string, request: UpdateCalendarConnectionRequest): Promise<CalendarConnection> {
+    return this.client.request(
+      'PATCH',
+      `${SCHEDULING_BASE_PATH}/me/calendar-connections/${encode(id)}`,
+      request,
+    )
+  }
+
+  async disconnectMine(id: string): Promise<void> {
+    await this.client.request(
+      'DELETE',
+      `${SCHEDULING_BASE_PATH}/me/calendar-connections/${encode(id)}`,
+    )
+  }
+
+  syncMine(id: string, request: UpdateCalendarSyncRequest = {}): Promise<CalendarConnection> {
+    return this.client.request<CalendarConnection>(
+      'POST',
+      `${SCHEDULING_BASE_PATH}/me/calendar-connections/${encode(id)}/sync`,
+      request,
+    )
+  }
+
+  listForUser(
+    userId: string,
+    query: ListCalendarConnectionsQuery = {},
+  ): Promise<ListResponse<CalendarConnection>> {
+    return this.client.requestWithQuery(
+      'GET',
+      `${SCHEDULING_BASE_PATH}/users/${encode(userId)}/calendar-connections`,
+      query,
+    )
+  }
+
+  updateForUser(
+    userId: string,
+    id: string,
+    request: UpdateCalendarConnectionRequest,
+  ): Promise<CalendarConnection> {
+    return this.client.request(
+      'PATCH',
+      `${SCHEDULING_BASE_PATH}/users/${encode(userId)}/calendar-connections/${encode(id)}`,
+      request,
+    )
+  }
+
+  async disconnectForUser(userId: string, id: string): Promise<void> {
+    await this.client.request(
+      'DELETE',
+      `${SCHEDULING_BASE_PATH}/users/${encode(userId)}/calendar-connections/${encode(id)}`,
+    )
+  }
+}
+
+/** Provider calendars under a connection + their platform roles. */
+export interface CalendarService {
+  listMine(query?: ListCalendarsQuery): Promise<ListResponse<Calendar>>
+  getMine(id: string): Promise<Calendar>
+  updateMine(id: string, request: UpdateCalendarRequest): Promise<Calendar>
+  listForUser(userId: string, query?: ListCalendarsQuery): Promise<ListResponse<Calendar>>
+  getForUser(userId: string, id: string): Promise<Calendar>
+  updateForUser(userId: string, id: string, request: UpdateCalendarRequest): Promise<Calendar>
+}
+
+class CalendarServiceImpl implements CalendarService {
+  constructor(private readonly client: ProteosClient) {}
+
+  listMine(query: ListCalendarsQuery = {}): Promise<ListResponse<Calendar>> {
+    return this.client.requestWithQuery('GET', `${SCHEDULING_BASE_PATH}/me/calendars`, query)
+  }
+
+  getMine(id: string): Promise<Calendar> {
+    return this.client.request('GET', `${SCHEDULING_BASE_PATH}/me/calendars/${encode(id)}`)
+  }
+
+  updateMine(id: string, request: UpdateCalendarRequest): Promise<Calendar> {
+    return this.client.request(
+      'PATCH',
+      `${SCHEDULING_BASE_PATH}/me/calendars/${encode(id)}`,
+      request,
+    )
+  }
+
+  listForUser(userId: string, query: ListCalendarsQuery = {}): Promise<ListResponse<Calendar>> {
+    return this.client.requestWithQuery(
+      'GET',
+      `${SCHEDULING_BASE_PATH}/users/${encode(userId)}/calendars`,
+      query,
+    )
+  }
+
+  getForUser(userId: string, id: string): Promise<Calendar> {
+    return this.client.request(
+      'GET',
+      `${SCHEDULING_BASE_PATH}/users/${encode(userId)}/calendars/${encode(id)}`,
+    )
+  }
+
+  updateForUser(userId: string, id: string, request: UpdateCalendarRequest): Promise<Calendar> {
+    return this.client.request(
+      'PATCH',
+      `${SCHEDULING_BASE_PATH}/users/${encode(userId)}/calendars/${encode(id)}`,
+      request,
+    )
+  }
+}
+
+/** Per-user scheduling settings (one per org + user; defaults when absent). */
+export interface SchedulingProfileService {
+  getMine(): Promise<SchedulingProfile>
+  putMine(request: PutSchedulingProfileRequest): Promise<SchedulingProfile>
+  getForUser(userId: string): Promise<SchedulingProfile>
+  putForUser(userId: string, request: PutSchedulingProfileRequest): Promise<SchedulingProfile>
+}
+
+class SchedulingProfileServiceImpl implements SchedulingProfileService {
+  constructor(private readonly client: ProteosClient) {}
+
+  getMine(): Promise<SchedulingProfile> {
+    return this.client.request('GET', `${SCHEDULING_BASE_PATH}/me/scheduling-profile`)
+  }
+
+  putMine(request: PutSchedulingProfileRequest): Promise<SchedulingProfile> {
+    return this.client.request('PUT', `${SCHEDULING_BASE_PATH}/me/scheduling-profile`, request)
+  }
+
+  getForUser(userId: string): Promise<SchedulingProfile> {
+    return this.client.request(
+      'GET',
+      `${SCHEDULING_BASE_PATH}/users/${encode(userId)}/scheduling-profile`,
+    )
+  }
+
+  putForUser(userId: string, request: PutSchedulingProfileRequest): Promise<SchedulingProfile> {
+    return this.client.request(
+      'PUT',
+      `${SCHEDULING_BASE_PATH}/users/${encode(userId)}/scheduling-profile`,
+      request,
+    )
+  }
+}
+
+/** The two-way calendar_event mirror. */
+export interface CalendarEventService {
+  /** A window of events (from/to required, ≤ 93 days); colleagues' events come back projected. */
+  list(query: ListCalendarEventsQuery): Promise<CalendarEventsResponse>
+  get(id: string): Promise<CalendarEvent>
+  /** Write an event through to the provider (calendar_id = own calendar, or hosts). */
+  create(request: CreateCalendarEventRequest): Promise<CalendarEvent>
+  /** Partial update; `scope` picks the instance or the whole series on recurring events. */
+  update(
+    id: string,
+    request: UpdateCalendarEventRequest,
+    scope?: RecurrenceScope,
+  ): Promise<CalendarEvent>
+  delete(id: string, scope?: RecurrenceScope): Promise<void>
+  /** Record the caller's RSVP. */
+  respond(id: string, request: RespondCalendarEventRequest): Promise<CalendarEvent>
+}
+
+class CalendarEventServiceImpl implements CalendarEventService {
+  constructor(private readonly client: ProteosClient) {}
+
+  list(query: ListCalendarEventsQuery): Promise<CalendarEventsResponse> {
+    return this.client.requestWithQuery('GET', `${SCHEDULING_BASE_PATH}/calendar-events`, query)
+  }
+
+  get(id: string): Promise<CalendarEvent> {
+    return this.client.request('GET', `${SCHEDULING_BASE_PATH}/calendar-events/${encode(id)}`)
+  }
+
+  create(request: CreateCalendarEventRequest): Promise<CalendarEvent> {
+    return this.client.request('POST', `${SCHEDULING_BASE_PATH}/calendar-events`, request)
+  }
+
+  update(
+    id: string,
+    request: UpdateCalendarEventRequest,
+    scope?: RecurrenceScope,
+  ): Promise<CalendarEvent> {
+    return this.client.requestWithQuery(
+      'PATCH',
+      `${SCHEDULING_BASE_PATH}/calendar-events/${encode(id)}`,
+      scope ? { scope } : undefined,
+      request,
+    )
+  }
+
+  async delete(id: string, scope?: RecurrenceScope): Promise<void> {
+    await this.client.requestWithQuery(
+      'DELETE',
+      `${SCHEDULING_BASE_PATH}/calendar-events/${encode(id)}`,
+      scope ? { scope } : undefined,
+    )
+  }
+
+  respond(id: string, request: RespondCalendarEventRequest): Promise<CalendarEvent> {
+    return this.client.request(
+      'POST',
+      `${SCHEDULING_BASE_PATH}/calendar-events/${encode(id)}/respond`,
+      request,
+    )
+  }
+}
+
+/** The slot-rules catalog: calendar event types, keyed by (org, key). */
+export interface CalendarEventTypeService {
+  list(query?: ListCalendarEventTypesQuery): Promise<ListResponse<CalendarEventType>>
+  get(key: string): Promise<CalendarEventType>
+  /** Create or replace (PUT semantics: every field is the new value). */
+  put(key: string, request: PutCalendarEventTypeRequest): Promise<CalendarEventType>
+  update(key: string, request: UpdateCalendarEventTypeRequest): Promise<CalendarEventType>
+  delete(key: string): Promise<void>
+}
+
+class CalendarEventTypeServiceImpl implements CalendarEventTypeService {
+  constructor(private readonly client: ProteosClient) {}
+
+  list(query: ListCalendarEventTypesQuery = {}): Promise<ListResponse<CalendarEventType>> {
+    return this.client.requestWithQuery('GET', `${SCHEDULING_BASE_PATH}/calendar-event-types`, query)
+  }
+
+  get(key: string): Promise<CalendarEventType> {
+    return this.client.request('GET', `${SCHEDULING_BASE_PATH}/calendar-event-types/${encode(key)}`)
+  }
+
+  put(key: string, request: PutCalendarEventTypeRequest): Promise<CalendarEventType> {
+    return this.client.request(
+      'PUT',
+      `${SCHEDULING_BASE_PATH}/calendar-event-types/${encode(key)}`,
+      request,
+    )
+  }
+
+  update(key: string, request: UpdateCalendarEventTypeRequest): Promise<CalendarEventType> {
+    return this.client.request(
+      'PATCH',
+      `${SCHEDULING_BASE_PATH}/calendar-event-types/${encode(key)}`,
+      request,
+    )
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.client.request(
+      'DELETE',
+      `${SCHEDULING_BASE_PATH}/calendar-event-types/${encode(key)}`,
+    )
+  }
+}
+
+/** A user's hours and blocks. `*Mine` = the caller's own; `*ForUser` = admin path. */
+export interface AvailabilityConstraintService {
+  listMine(query?: ListAvailabilityConstraintsQuery): Promise<ListResponse<AvailabilityConstraint>>
+  getMine(id: string): Promise<AvailabilityConstraint>
+  createMine(request: CreateAvailabilityConstraintRequest): Promise<AvailabilityConstraint>
+  updateMine(id: string, request: UpdateAvailabilityConstraintRequest): Promise<AvailabilityConstraint>
+  deleteMine(id: string): Promise<void>
+  listForUser(
+    userId: string,
+    query?: ListAvailabilityConstraintsQuery,
+  ): Promise<ListResponse<AvailabilityConstraint>>
+  getForUser(userId: string, id: string): Promise<AvailabilityConstraint>
+  createForUser(
+    userId: string,
+    request: CreateAvailabilityConstraintRequest,
+  ): Promise<AvailabilityConstraint>
+  updateForUser(
+    userId: string,
+    id: string,
+    request: UpdateAvailabilityConstraintRequest,
+  ): Promise<AvailabilityConstraint>
+  deleteForUser(userId: string, id: string): Promise<void>
+}
+
+class AvailabilityConstraintServiceImpl implements AvailabilityConstraintService {
+  constructor(private readonly client: ProteosClient) {}
+
+  private base(userId?: string): string {
+    return userId
+      ? `${SCHEDULING_BASE_PATH}/users/${encode(userId)}/availability-constraints`
+      : `${SCHEDULING_BASE_PATH}/me/availability-constraints`
+  }
+
+  listMine(query: ListAvailabilityConstraintsQuery = {}): Promise<ListResponse<AvailabilityConstraint>> {
+    return this.client.requestWithQuery('GET', this.base(), query)
+  }
+
+  getMine(id: string): Promise<AvailabilityConstraint> {
+    return this.client.request('GET', `${this.base()}/${encode(id)}`)
+  }
+
+  createMine(request: CreateAvailabilityConstraintRequest): Promise<AvailabilityConstraint> {
+    return this.client.request('POST', this.base(), request)
+  }
+
+  updateMine(id: string, request: UpdateAvailabilityConstraintRequest): Promise<AvailabilityConstraint> {
+    return this.client.request('PATCH', `${this.base()}/${encode(id)}`, request)
+  }
+
+  async deleteMine(id: string): Promise<void> {
+    await this.client.request('DELETE', `${this.base()}/${encode(id)}`)
+  }
+
+  listForUser(
+    userId: string,
+    query: ListAvailabilityConstraintsQuery = {},
+  ): Promise<ListResponse<AvailabilityConstraint>> {
+    return this.client.requestWithQuery('GET', this.base(userId), query)
+  }
+
+  getForUser(userId: string, id: string): Promise<AvailabilityConstraint> {
+    return this.client.request('GET', `${this.base(userId)}/${encode(id)}`)
+  }
+
+  createForUser(
+    userId: string,
+    request: CreateAvailabilityConstraintRequest,
+  ): Promise<AvailabilityConstraint> {
+    return this.client.request('POST', this.base(userId), request)
+  }
+
+  updateForUser(
+    userId: string,
+    id: string,
+    request: UpdateAvailabilityConstraintRequest,
+  ): Promise<AvailabilityConstraint> {
+    return this.client.request('PATCH', `${this.base(userId)}/${encode(id)}`, request)
+  }
+
+  async deleteForUser(userId: string, id: string): Promise<void> {
+    await this.client.request('DELETE', `${this.base(userId)}/${encode(id)}`)
+  }
+}
+
+/** The slot engine: bookable starts of some hosts under a type's / explicit rules. */
+export interface SlotService {
+  get(request: GetSlotsRequest): Promise<GetSlotsResponse>
+}
+
+class SlotServiceImpl implements SlotService {
+  constructor(private readonly client: ProteosClient) {}
+
+  get(request: GetSlotsRequest): Promise<GetSlotsResponse> {
+    return this.client.request('POST', `${SCHEDULING_BASE_PATH}/slots`, request)
+  }
+}
+
+/** Scheduling links: the entry points for taking a slot, plus booking through one. */
+export interface SchedulingLinkService {
+  list(query?: ListSchedulingLinksQuery): Promise<ListResponse<SchedulingLink>>
+  get(key: string): Promise<SchedulingLink>
+  create(request: CreateSchedulingLinkRequest): Promise<SchedulingLink>
+  update(key: string, request: UpdateSchedulingLinkRequest): Promise<SchedulingLink>
+  delete(key: string): Promise<void>
+  /** The link as an embedded scheduling picker renders it (types, hosts, policy) — private links included. */
+  getPage(key: string, contactId?: string): Promise<PublicSchedulingLink>
+  /** The link's slots (its hosts + assignment, its type's rules). */
+  getSlots(key: string, query: GetPublicSlotsQuery): Promise<GetSlotsResponse>
+  /** Take a slot through the link (scheduling-links:read); an empty contact books for the caller. */
+  book(key: string, request: BookSchedulingLinkRequest): Promise<BookSchedulingLinkResponse>
+}
+
+class SchedulingLinkServiceImpl implements SchedulingLinkService {
+  constructor(private readonly client: ProteosClient) {}
+
+  list(query: ListSchedulingLinksQuery = {}): Promise<ListResponse<SchedulingLink>> {
+    return this.client.requestWithQuery('GET', `${SCHEDULING_BASE_PATH}/scheduling-links`, query)
+  }
+
+  get(key: string): Promise<SchedulingLink> {
+    return this.client.request('GET', `${SCHEDULING_BASE_PATH}/scheduling-links/${encode(key)}`)
+  }
+
+  create(request: CreateSchedulingLinkRequest): Promise<SchedulingLink> {
+    return this.client.request('POST', `${SCHEDULING_BASE_PATH}/scheduling-links`, request)
+  }
+
+  update(key: string, request: UpdateSchedulingLinkRequest): Promise<SchedulingLink> {
+    return this.client.request('PATCH', `${SCHEDULING_BASE_PATH}/scheduling-links/${encode(key)}`, request)
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.client.request('DELETE', `${SCHEDULING_BASE_PATH}/scheduling-links/${encode(key)}`)
+  }
+
+  getPage(key: string, contactId?: string): Promise<PublicSchedulingLink> {
+    const suffix = contactId ? `?contact_id=${encode(contactId)}` : ''
+    return this.client.request('GET', `${SCHEDULING_BASE_PATH}/scheduling-links/${encode(key)}/page${suffix}`)
+  }
+
+  getSlots(key: string, query: GetPublicSlotsQuery): Promise<GetSlotsResponse> {
+    return this.client.requestWithQuery('GET', `${SCHEDULING_BASE_PATH}/scheduling-links/${encode(key)}/slots`, query)
+  }
+
+  book(key: string, request: BookSchedulingLinkRequest): Promise<BookSchedulingLinkResponse> {
+    return this.client.request('POST', `${SCHEDULING_BASE_PATH}/scheduling-links/${encode(key)}/calendar-events`, request)
+  }
+}
+
+/**
+ * The unauthenticated scheduling surface: every call sends NO Authorization
+ * header (skipAuth), so it is safe on the anonymous /s/ routes. Links answer
+ * only when public + enabled; events only with their manage token.
+ */
+export interface PublicSchedulingService {
+  getLink(orgId: string, key: string, contactId?: string): Promise<PublicSchedulingLink>
+  getSlots(orgId: string, key: string, query: GetPublicSlotsQuery): Promise<GetSlotsResponse>
+  book(orgId: string, key: string, request: BookSchedulingLinkRequest): Promise<PublicBookSchedulingLinkResponse>
+  getEvent(orgId: string, id: string, token: string): Promise<PublicCalendarEvent>
+  cancel(orgId: string, id: string, request: CancelPublicCalendarEventRequest): Promise<PublicCalendarEvent>
+  reschedule(orgId: string, id: string, request: ReschedulePublicCalendarEventRequest): Promise<PublicBookSchedulingLinkResponse>
+}
+
+class PublicSchedulingServiceImpl implements PublicSchedulingService {
+  constructor(private readonly client: ProteosClient) {}
+
+  private base(orgId: string): string {
+    return `${SCHEDULING_BASE_PATH}/public/orgs/${encode(orgId)}`
+  }
+
+  getLink(orgId: string, key: string, contactId?: string): Promise<PublicSchedulingLink> {
+    const suffix = contactId ? `?contact_id=${encode(contactId)}` : ''
+    return this.client.request('GET', `${this.base(orgId)}/links/${encode(key)}${suffix}`, undefined, { skipAuth: true })
+  }
+
+  getSlots(orgId: string, key: string, query: GetPublicSlotsQuery): Promise<GetSlotsResponse> {
+    const params = new URLSearchParams({ from: query.from, to: query.to, timezone: query.timezone })
+    if (query.host_user_id) params.set('host_user_id', query.host_user_id)
+    if (query.type_key) params.set('type_key', query.type_key)
+    return this.client.request('GET', `${this.base(orgId)}/links/${encode(key)}/slots?${params.toString()}`, undefined, { skipAuth: true })
+  }
+
+  book(orgId: string, key: string, request: BookSchedulingLinkRequest): Promise<PublicBookSchedulingLinkResponse> {
+    return this.client.request('POST', `${this.base(orgId)}/links/${encode(key)}/calendar-events`, request, { skipAuth: true })
+  }
+
+  getEvent(orgId: string, id: string, token: string): Promise<PublicCalendarEvent> {
+    return this.client.request('GET', `${this.base(orgId)}/calendar-events/${encode(id)}?token=${encode(token)}`, undefined, { skipAuth: true })
+  }
+
+  cancel(orgId: string, id: string, request: CancelPublicCalendarEventRequest): Promise<PublicCalendarEvent> {
+    return this.client.request('POST', `${this.base(orgId)}/calendar-events/${encode(id)}/cancel`, request, { skipAuth: true })
+  }
+
+  reschedule(orgId: string, id: string, request: ReschedulePublicCalendarEventRequest): Promise<PublicBookSchedulingLinkResponse> {
+    return this.client.request('POST', `${this.base(orgId)}/calendar-events/${encode(id)}/reschedule`, request, { skipAuth: true })
+  }
+}