@gpt-platform/client 0.10.5 → 0.11.0

package/dist/namespaces/scheduling.d.ts

@@ -0,0 +1,944 @@
+import type { SchedulingEventType, SchedulingEvent, SchedulingParticipant, SchedulingBooking, SchedulingCalendarSync } from "../_internal/types.gen";
+export type { SessionNoteType, SessionNoteValue } from "./session-notes";
+/** Attributes accepted when creating an event type. */
+export type CreateSchedulingEventTypeAttributes = {
+    workspace_id: string;
+    name: string;
+    duration_minutes?: number;
+    capacity?: number;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating an event type (PATCH semantics). */
+export type UpdateSchedulingEventTypeAttributes = {
+    name?: string;
+    duration_minutes?: number;
+    capacity?: number;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a scheduling event. */
+export type CreateSchedulingEventAttributes = {
+    workspace_id: string;
+    event_type_id?: string;
+    title?: string;
+    start_time: string;
+    end_time: string;
+    participant_ids?: string[];
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a scheduling event (PATCH semantics). */
+export type UpdateSchedulingEventAttributes = {
+    title?: string;
+    start_time?: string;
+    end_time?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a participant. */
+export type CreateSchedulingParticipantAttributes = {
+    event_id: string;
+    user_id?: string;
+    email?: string;
+    name?: string;
+    contact_id?: string;
+    role?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a participant (PATCH semantics). */
+export type UpdateSchedulingParticipantAttributes = {
+    status?: string;
+    role?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a booking. */
+export type CreateSchedulingBookingAttributes = {
+    workspace_id: string;
+    event_type_id: string;
+    start_time: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when cancelling a booking. */
+export type CancelSchedulingBookingAttributes = {
+    reason?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when rescheduling a booking. */
+export type RescheduleSchedulingBookingAttributes = {
+    start_time: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a calendar sync. */
+export type CreateSchedulingCalendarSyncAttributes = {
+    workspace_id: string;
+    provider: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a calendar sync (PATCH semantics). */
+export type UpdateSchedulingCalendarSyncAttributes = {
+    enabled?: boolean;
+    [key: string]: unknown;
+};
+import type { RequestOptions } from "../base-client";
+import { RequestBuilder } from "../request-builder";
+/**
+ * Scheduling namespace for appointment booking, event management, calendar
+ * synchronization, and meeting coordination.
+ *
+ * Access via `client.scheduling`.
+ *
+ * The scheduling system is organized into four layers:
+ * 1. **Event Types** — reusable templates for bookable appointments (e.g.,
+ *    "30-Minute Consultation"). Define duration, location, and approval rules.
+ * 2. **Events** — internal scheduled occurrences between known workspace members.
+ * 3. **Bookings** — external party requests against event types (e.g., a patient
+ *    booking an appointment via a public link).
+ * 4. **Calendar Syncs** — bi-directional sync with external calendars.
+ *
+ * @example
+ * ```typescript
+ * const client = new GptClient({ apiKey: 'sk_app_...' });
+ *
+ * // List available appointment types
+ * const eventTypes = await client.scheduling.eventTypes.list();
+ *
+ * // Book an appointment
+ * const booking = await client.scheduling.bookings.create({
+ *   event_type_id: eventTypes[0].id,
+ *   start_time: '2026-04-01T10:00:00Z',
+ *   booker_email: 'patient@example.com',
+ *   booker_name: 'John Patient',
+ * });
+ * ```
+ */
+export declare function createSchedulingNamespace(rb: RequestBuilder): {
+    /**
+     * Event Types — reusable templates for bookable appointment slots.
+     *
+     * An `EventType` defines the configuration for a bookable appointment:
+     * name, slug (used in public booking URLs), duration, location type
+     * (video, phone, in-person), and whether bookings require approval.
+     * Multiple bookings can be created against the same event type.
+     */
+    eventTypes: {
+        /**
+         * List event types with optional pagination.
+         *
+         * Returns one page of event types. Use `listAll` to automatically
+         * traverse all pages.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `SchedulingEventType` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const types = await client.scheduling.eventTypes.list({ pageSize: 20 });
+         * types.forEach(t => console.log(t.attributes?.name, t.attributes?.duration_minutes));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<SchedulingEventType[]>;
+        /**
+         * List all event types, automatically paginating through every page.
+         *
+         * @param options - Optional request options.
+         * @returns All `SchedulingEventType` records as a flat array.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const allTypes = await client.scheduling.eventTypes.listAll();
+         * ```
+         */
+        listAll: (options?: RequestOptions) => Promise<SchedulingEventType[]>;
+        /**
+         * Retrieve a single event type by its ID.
+         *
+         * @param id - The UUID of the event type.
+         * @param options - Optional request options.
+         * @returns The matching `SchedulingEventType`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const eventType = await client.scheduling.eventTypes.get('et_abc123');
+         * console.log(eventType.attributes?.slug, eventType.attributes?.location_type);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<SchedulingEventType>;
+        /**
+         * Create a new event type.
+         *
+         * Defines a new bookable appointment template. Required attributes:
+         * `name` and `duration_minutes`. Optional but recommended: `slug`
+         * (used in public booking URLs; auto-generated from name if omitted),
+         * `location_type` (`"video"` | `"phone"` | `"in_person"`),
+         * `requires_approval` (default `false`), and `description`.
+         *
+         * @param attributes - Event type attributes. `name` and `duration_minutes`
+         *   are required.
+         * @param options - Optional request options.
+         * @returns The newly created `SchedulingEventType`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const eventType = await client.scheduling.eventTypes.create({
+         *   name: '30-Minute Consultation',
+         *   slug: '30min-consult',
+         *   duration_minutes: 30,
+         *   location_type: 'video',
+         *   requires_approval: false,
+         *   description: 'A brief video call for initial consultations.',
+         * });
+         * console.log('Event type created:', eventType.id);
+         * ```
+         */
+        create: (attributes: CreateSchedulingEventTypeAttributes, options?: RequestOptions) => Promise<SchedulingEventType>;
+        /**
+         * Update an existing event type.
+         *
+         * Use to change the name, duration, location type, or approval settings
+         * of an event type. Changes take effect for new bookings; existing bookings
+         * are not retroactively modified.
+         *
+         * @param id - The UUID of the event type to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingEventType`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const eventType = await client.scheduling.eventTypes.update('et_abc123', {
+         *   duration_minutes: 45,
+         *   requires_approval: true,
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateSchedulingEventTypeAttributes, options?: RequestOptions) => Promise<SchedulingEventType>;
+        /**
+         * Archive an event type.
+         *
+         * Marks the event type as archived so it no longer appears in active
+         * listings. Existing bookings against this event type are unaffected.
+         *
+         * @param id - The UUID of the event type to archive.
+         * @param options - Optional request options.
+         * @returns The archived `SchedulingEventType`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const archived = await client.scheduling.eventTypes.archive('et_abc123');
+         * console.log(archived.attributes?.status); // 'archived'
+         * ```
+         */
+        archive: (id: string, options?: RequestOptions) => Promise<SchedulingEventType>;
+        /**
+         * Retrieve an event type by its public slug.
+         *
+         * Slugs are unique per workspace and used in public booking URLs.
+         * This is the primary lookup method for external-facing booking pages.
+         *
+         * @param slug - The URL-safe slug of the event type.
+         * @param workspaceId - The workspace that owns the event type.
+         * @param options - Optional request options.
+         * @returns The matching `SchedulingEventType`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const eventType = await client.scheduling.eventTypes.getBySlug(
+         *   '30min-consult', 'ws_abc123',
+         * );
+         * console.log(eventType.attributes?.name);
+         * ```
+         */
+        getBySlug: (slug: string, workspaceId: string, options?: RequestOptions) => Promise<SchedulingEventType>;
+    };
+    /**
+     * Events — scheduled occurrences between workspace members.
+     *
+     * Events represent internal calendar entries (meetings, calls, appointments)
+     * between users who are already members of the workspace. For booking flows
+     * where external parties request time, use `bookings` instead.
+     */
+    events: {
+        /**
+         * List scheduling events in a workspace with optional pagination.
+         *
+         * @param workspaceId - The workspace to list events for.
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `SchedulingEvent` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const events = await client.scheduling.events.list(workspaceId, { pageSize: 25 });
+         * events.forEach(e => console.log(e.attributes?.title, e.attributes?.start_time));
+         * ```
+         */
+        list: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<SchedulingEvent[]>;
+        /**
+         * List all scheduling events in a workspace, automatically paginating through every page.
+         *
+         * @param workspaceId - The workspace to list events for.
+         * @param options - Optional request options.
+         * @returns All `SchedulingEvent` records as a flat array.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const allEvents = await client.scheduling.events.listAll(workspaceId);
+         * ```
+         */
+        listAll: (workspaceId: string, options?: RequestOptions) => Promise<SchedulingEvent[]>;
+        /**
+         * Retrieve a single scheduling event by its ID.
+         *
+         * @param id - The UUID of the scheduling event.
+         * @param options - Optional request options.
+         * @returns The matching `SchedulingEvent`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const event = await client.scheduling.events.get('se_abc123');
+         * console.log(event.attributes?.start_time, event.attributes?.end_time);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<SchedulingEvent>;
+        /**
+         * Create an internal scheduling event directly.
+         *
+         * Creates a calendar event for meetings between known workspace members.
+         * Unlike bookings (which go through an event type and approval flow),
+         * events are created directly. Typical attributes: `title`, `start_time`,
+         * `end_time`, `location_type`, and an array of `participant_ids`.
+         *
+         * @param attributes - Event attributes. `title`, `start_time`, and
+         *   `end_time` are required.
+         * @param options - Optional request options.
+         * @returns The newly created `SchedulingEvent`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const event = await client.scheduling.events.create({
+         *   title: 'Weekly Team Sync',
+         *   start_time: '2026-04-07T09:00:00Z',
+         *   end_time: '2026-04-07T09:30:00Z',
+         *   location_type: 'video',
+         *   participant_ids: ['user_abc', 'user_def'],
+         * });
+         * ```
+         */
+        create: (attributes: CreateSchedulingEventAttributes, options?: RequestOptions) => Promise<SchedulingEvent>;
+        /**
+         * Update a scheduling event.
+         *
+         * Use to change the event title, time, location, or other attributes.
+         * Participants receive update notifications if notification settings
+         * are enabled.
+         *
+         * @param id - The UUID of the scheduling event to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingEvent`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const event = await client.scheduling.events.update('se_abc123', {
+         *   start_time: '2026-04-07T10:00:00Z',
+         *   end_time: '2026-04-07T10:30:00Z',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateSchedulingEventAttributes, options?: RequestOptions) => Promise<SchedulingEvent>;
+        /**
+         * Cancel an event.
+         *
+         * @param id - The UUID of the event to cancel.
+         * @param attributes - Optional attributes (e.g., `{ cancellation_reason }`).
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingEvent` with `status: "cancelled"`.
+         *
+         * @example
+         * ```typescript
+         * const event = await client.scheduling.events.cancel('se_abc123', {
+         *   cancellation_reason: 'Schedule conflict',
+         * });
+         * ```
+         */
+        cancel: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<SchedulingEvent>;
+        /**
+         * Mark an event as completed.
+         *
+         * @param id - The UUID of the event to complete.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingEvent` with `status: "completed"`.
+         *
+         * @example
+         * ```typescript
+         * const event = await client.scheduling.events.complete('se_abc123');
+         * ```
+         */
+        complete: (id: string, options?: RequestOptions) => Promise<SchedulingEvent>;
+        /**
+         * Reschedule an event to a new time.
+         *
+         * @param id - The UUID of the event to reschedule.
+         * @param attributes - Must include `new_start_time` and `new_end_time`.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingEvent` with the new times.
+         *
+         * @example
+         * ```typescript
+         * const event = await client.scheduling.events.reschedule('se_abc123', {
+         *   new_start_time: '2026-04-10T14:00:00Z',
+         *   new_end_time: '2026-04-10T15:00:00Z',
+         * });
+         * ```
+         */
+        reschedule: (id: string, attributes: {
+            new_start_time: string;
+            new_end_time: string;
+        }, options?: RequestOptions) => Promise<SchedulingEvent>;
+        /**
+         * List events within a date range.
+         *
+         * @param workspaceId - The workspace UUID.
+         * @param startTime - ISO 8601 range start.
+         * @param endTime - ISO 8601 range end.
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `SchedulingEvent` records in the range.
+         *
+         * @example
+         * ```typescript
+         * const events = await client.scheduling.events.listByDateRange(
+         *   workspaceId, '2026-04-01T00:00:00Z', '2026-04-30T23:59:59Z',
+         * );
+         * ```
+         */
+        listByDateRange: (workspaceId: string, startTime: string, endTime: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<SchedulingEvent[]>;
+        /**
+         * List events that include a specific participant by email.
+         *
+         * Use this to retrieve all sessions for a client (e.g., all appointments
+         * for a given patient). Filters events in the workspace where a Participant
+         * record with the given email exists.
+         *
+         * @param email - The participant's email address to filter by.
+         * @param workspaceId - The workspace to scope the query to.
+         * @param options - Optional page number, page size, and request options.
+         * @returns A flat array of `SchedulingEvent` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const sessions = await client.scheduling.events.listByParticipant(
+         *   'patient@example.com',
+         *   workspaceId,
+         * );
+         * sessions.forEach(s => console.log(s.attributes?.start_time, s.attributes?.status));
+         * ```
+         */
+        listByParticipant: (email: string, workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<SchedulingEvent[]>;
+    };
+    /**
+     * Participants — people attending scheduling events.
+     *
+     * Participants are associated with both internal `events` and external
+     * `bookings`. Each participant record tracks the person's identity,
+     * their RSVP response, and their role in the event.
+     */
+    participants: {
+        /**
+         * List participants with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `SchedulingParticipant` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const participants = await client.scheduling.participants.list();
+         * participants.forEach(p => console.log(p.attributes?.user_id, p.attributes?.status));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<SchedulingParticipant[]>;
+        /**
+         * List all participants, automatically paginating through every page.
+         *
+         * @param options - Optional request options.
+         * @returns All `SchedulingParticipant` records as a flat array.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const allParticipants = await client.scheduling.participants.listAll();
+         * ```
+         */
+        listAll: (options?: RequestOptions) => Promise<SchedulingParticipant[]>;
+        /**
+         * Retrieve a single participant by their ID.
+         *
+         * @param id - The UUID of the scheduling participant.
+         * @param options - Optional request options.
+         * @returns The matching `SchedulingParticipant`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const participant = await client.scheduling.participants.get('sp_abc123');
+         * console.log(participant.attributes?.status, participant.attributes?.role);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<SchedulingParticipant>;
+        /**
+         * Add a participant to a scheduling event.
+         *
+         * Creates a participant record linking a user or external contact to
+         * an event. Typical attributes: `event_id` (or `booking_id`), `user_id`
+         * (or `email` for external participants), and `role`
+         * (e.g., `"attendee"`, `"organizer"`).
+         *
+         * @param attributes - Participant attributes. `event_id` and either
+         *   `user_id` or `email` are required.
+         * @param options - Optional request options.
+         * @returns The newly created `SchedulingParticipant`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const participant = await client.scheduling.participants.create({
+         *   event_id: 'se_abc123',
+         *   user_id: 'user_xyz',
+         *   role: 'attendee',
+         * });
+         * ```
+         */
+        create: (attributes: CreateSchedulingParticipantAttributes, options?: RequestOptions) => Promise<SchedulingParticipant>;
+        /**
+         * Update a participant record — confirm attendance or respond to an invite.
+         *
+         * Use to record an RSVP response or update the participant's role.
+         * Typical attributes: `status` (`"accepted"` | `"declined"` | `"tentative"`).
+         *
+         * @param id - The UUID of the scheduling participant to update.
+         * @param attributes - Attribute map of fields to change. Typically
+         *   `{ status: "accepted" }` for an RSVP confirmation.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingParticipant`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const participant = await client.scheduling.participants.update('sp_abc123', {
+         *   status: 'accepted',
+         * });
+         * console.log(participant.attributes?.status); // "accepted"
+         * ```
+         */
+        update: (id: string, attributes: UpdateSchedulingParticipantAttributes, options?: RequestOptions) => Promise<SchedulingParticipant>;
+        /**
+         * Record a participant's RSVP response.
+         *
+         * @param id - The UUID of the participant.
+         * @param status - The RSVP response: `"accepted"`, `"declined"`, or `"tentative"`.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingParticipant`.
+         *
+         * @example
+         * ```typescript
+         * const p = await client.scheduling.participants.respond('sp_abc123', 'accepted');
+         * ```
+         */
+        respond: (id: string, status: "accepted" | "declined" | "tentative", options?: RequestOptions) => Promise<SchedulingParticipant>;
+        /**
+         * Remove a participant from an event.
+         *
+         * @param id - The UUID of the participant to remove.
+         * @param options - Optional request options.
+         * @returns `true` on successful removal.
+         *
+         * @example
+         * ```typescript
+         * await client.scheduling.participants.remove('sp_abc123');
+         * ```
+         */
+        remove: (id: string, options?: RequestOptions) => Promise<true>;
+    };
+    /**
+     * Bookings — external party appointment requests.
+     *
+     * Bookings represent requests from people outside the platform (e.g.,
+     * patients, clients) who want to schedule time against a published
+     * `EventType`. Unlike internal `events`, bookings go through a request
+     * → confirm/reject lifecycle.
+     *
+     * Typical flow:
+     * 1. External party submits a booking via a public booking link.
+     * 2. `create` is called with the event type and desired time.
+     * 3. If the event type has `requires_approval: true`, a workspace member
+     *    calls `confirm` or `cancel` to respond.
+     * 4. `reschedule` can move the booking to a new time.
+     */
+    bookings: {
+        /**
+         * List bookings with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `SchedulingBooking` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const bookings = await client.scheduling.bookings.list();
+         * bookings.forEach(b => console.log(b.attributes?.booker_email, b.attributes?.status));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<SchedulingBooking[]>;
+        /**
+         * List all bookings, automatically paginating through every page.
+         *
+         * @param options - Optional request options.
+         * @returns All `SchedulingBooking` records as a flat array.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const allBookings = await client.scheduling.bookings.listAll();
+         * ```
+         */
+        listAll: (options?: RequestOptions) => Promise<SchedulingBooking[]>;
+        /**
+         * Retrieve a single booking by its ID.
+         *
+         * @param id - The UUID of the booking.
+         * @param options - Optional request options.
+         * @returns The matching `SchedulingBooking`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const booking = await client.scheduling.bookings.get('sb_abc123');
+         * console.log(booking.attributes?.start_time, booking.attributes?.status);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<SchedulingBooking>;
+        /**
+         * Create a new booking request.
+         *
+         * Submits a request to book time against an event type. Used when an
+         * external party (patient, client) wants to schedule an appointment.
+         * Required attributes: `event_type_id`, `start_time`, `booker_name`,
+         * `booker_email`. Optional: `notes`, `timezone`.
+         *
+         * If the event type has `requires_approval: true`, the booking is
+         * created in `pending` status awaiting confirmation via `confirm`.
+         * Otherwise it is immediately `confirmed`.
+         *
+         * @param attributes - Booking attributes. `event_type_id`, `start_time`,
+         *   `booker_name`, and `booker_email` are required.
+         * @param options - Optional request options.
+         * @returns The newly created `SchedulingBooking`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const booking = await client.scheduling.bookings.create({
+         *   event_type_id: 'et_abc123',
+         *   start_time: '2026-04-15T14:00:00Z',
+         *   booker_name: 'Jane Patient',
+         *   booker_email: 'jane@example.com',
+         *   notes: 'First visit — annual wellness check.',
+         * });
+         * console.log('Booking created:', booking.id, booking.attributes?.status);
+         * ```
+         */
+        create: (attributes: CreateSchedulingBookingAttributes, options?: RequestOptions) => Promise<SchedulingBooking>;
+        /**
+         * Confirm a pending booking.
+         *
+         * Approves a booking that was created against an event type with
+         * `requires_approval: true`. Transitions the booking from `pending`
+         * to `confirmed` status. The booker typically receives a confirmation
+         * notification.
+         *
+         * @param id - The UUID of the booking to confirm.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingBooking` with `status: "confirmed"`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const booking = await client.scheduling.bookings.confirm('sb_abc123');
+         * console.log(booking.attributes?.status); // "confirmed"
+         * ```
+         */
+        confirm: (id: string, options?: RequestOptions) => Promise<SchedulingBooking>;
+        /**
+         * Cancel or reject a booking.
+         *
+         * Cancels a booking in any non-terminal status. Optional `attributes`
+         * can include a `reason` or `cancellation_note` to communicate context
+         * to the booker. Cancelled bookings are retained for audit purposes.
+         *
+         * @param id - The UUID of the booking to cancel.
+         * @param attributes - Optional cancellation attributes (e.g., `{ reason }`).
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingBooking` with `status: "cancelled"`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const booking = await client.scheduling.bookings.cancel('sb_abc123', {
+         *   reason: 'Clinician unavailable due to emergency.',
+         * });
+         * console.log(booking.attributes?.status); // "cancelled"
+         * ```
+         */
+        cancel: (id: string, attributes?: CancelSchedulingBookingAttributes, options?: RequestOptions) => Promise<SchedulingBooking>;
+        /**
+         * Reschedule a booking to a new time.
+         *
+         * Moves a confirmed booking to a different start time. Required
+         * attributes: `new_start_time`. The booking's `event_type_id` and
+         * other details remain unchanged. The booker typically receives a
+         * reschedule notification.
+         *
+         * @param id - The UUID of the booking to reschedule.
+         * @param attributes - Reschedule attributes including `new_start_time`.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingBooking` with the new time.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const booking = await client.scheduling.bookings.reschedule('sb_abc123', {
+         *   new_start_time: '2026-04-22T14:00:00Z',
+         * });
+         * console.log(booking.attributes?.start_time); // "2026-04-22T14:00:00Z"
+         * ```
+         */
+        reschedule: (id: string, attributes: RescheduleSchedulingBookingAttributes, options?: RequestOptions) => Promise<SchedulingBooking>;
+        /**
+         * Mark a booking as no-show.
+         *
+         * Records that the booker did not attend the appointment.
+         *
+         * @param id - The UUID of the booking.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingBooking` with `status: "no_show"`.
+         *
+         * @example
+         * ```typescript
+         * const booking = await client.scheduling.bookings.markNoShow('sb_abc123');
+         * ```
+         */
+        markNoShow: (id: string, options?: RequestOptions) => Promise<SchedulingBooking>;
+        /**
+         * List bookings by booker email address.
+         *
+         * Returns all bookings associated with the given booker email,
+         * regardless of status. Useful for lookup pages where a booker
+         * wants to view or manage their appointments.
+         *
+         * @param email - The booker's email address.
+         * @param options - Optional request options.
+         * @returns An array of `SchedulingBooking` records for that booker.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const bookings = await client.scheduling.bookings.listByBooker(
+         *   'patient@example.com',
+         * );
+         * bookings.forEach(b => console.log(b.attributes?.start_time, b.attributes?.status));
+         * ```
+         */
+        listByBooker: (email: string, options?: RequestOptions) => Promise<SchedulingBooking[]>;
+    };
+    /**
+     * Calendar Syncs — bi-directional external calendar integrations.
+     *
+     * Calendar syncs connect the platform's scheduling system to external
+     * calendars (Google Calendar, Microsoft Outlook). When active, events
+     * are pushed to the external calendar and external events are pulled
+     * in to detect conflicts. Syncs can be paused without deleting the
+     * integration configuration.
+     */
+    calendarSyncs: {
+        /**
+         * List calendar syncs with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `SchedulingCalendarSync` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const syncs = await client.scheduling.calendarSyncs.list();
+         * syncs.forEach(s => console.log(s.attributes?.provider, s.attributes?.status));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<SchedulingCalendarSync[]>;
+        /**
+         * List all calendar syncs, automatically paginating through every page.
+         *
+         * @param options - Optional request options.
+         * @returns All `SchedulingCalendarSync` records as a flat array.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const allSyncs = await client.scheduling.calendarSyncs.listAll();
+         * ```
+         */
+        listAll: (options?: RequestOptions) => Promise<SchedulingCalendarSync[]>;
+        /**
+         * Retrieve a single calendar sync by its ID.
+         *
+         * @param id - The UUID of the calendar sync.
+         * @param options - Optional request options.
+         * @returns The matching `SchedulingCalendarSync`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const sync = await client.scheduling.calendarSyncs.get('cs_abc123');
+         * console.log(sync.attributes?.provider, sync.attributes?.last_synced_at);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<SchedulingCalendarSync>;
+        /**
+         * Create a new calendar sync integration.
+         *
+         * Sets up bi-directional sync between the platform and an external calendar.
+         * Requires a pre-authorized connector credential for the calendar provider.
+         * Typical attributes: `provider` (`"google_calendar"` | `"outlook"`),
+         * `connector_instance_id`, `workspace_id`, and `sync_direction`
+         * (`"both"` | `"push"` | `"pull"`).
+         *
+         * @param attributes - Calendar sync attributes. `provider` and
+         *   `connector_instance_id` are required.
+         * @param options - Optional request options.
+         * @returns The newly created `SchedulingCalendarSync`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const sync = await client.scheduling.calendarSyncs.create({
+         *   provider: 'google_calendar',
+         *   connector_instance_id: 'ci_gcal_abc',
+         *   workspace_id: 'ws_abc123',
+         *   sync_direction: 'both',
+         * });
+         * console.log('Calendar sync created:', sync.id);
+         * ```
+         */
+        create: (attributes: CreateSchedulingCalendarSyncAttributes, options?: RequestOptions) => Promise<SchedulingCalendarSync>;
+        /**
+         * Update a calendar sync configuration.
+         *
+         * Use to change sync direction, update the associated credential, or
+         * modify other sync settings.
+         *
+         * @param id - The UUID of the calendar sync to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingCalendarSync`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const sync = await client.scheduling.calendarSyncs.update('cs_abc123', {
+         *   sync_direction: 'push',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateSchedulingCalendarSyncAttributes, options?: RequestOptions) => Promise<SchedulingCalendarSync>;
+        /**
+         * Delete a calendar sync integration.
+         *
+         * Removes the calendar sync configuration permanently. The integration
+         * stops immediately. Events previously synced to the external calendar
+         * are not removed from the external calendar.
+         *
+         * @param id - The UUID of the calendar sync to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.scheduling.calendarSyncs.delete('cs_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * Pause a calendar sync.
+         *
+         * Temporarily suspends the sync without deleting the integration.
+         * While paused, no events are pushed to or pulled from the external
+         * calendar. Resume with `resume` when ready to continue syncing.
+         *
+         * @param id - The UUID of the calendar sync to pause.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingCalendarSync` with `status: "paused"`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const sync = await client.scheduling.calendarSyncs.pause('cs_abc123');
+         * console.log(sync.attributes?.status); // "paused"
+         * ```
+         */
+        pause: (id: string, options?: RequestOptions) => Promise<SchedulingCalendarSync>;
+        /**
+         * Resume a paused calendar sync.
+         *
+         * Restarts a calendar sync that was previously paused. The sync catches
+         * up on any missed changes since the pause, then resumes normal operation.
+         *
+         * @param id - The UUID of the calendar sync to resume.
+         * @param options - Optional request options.
+         * @returns The updated `SchedulingCalendarSync` with `status: "active"`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const sync = await client.scheduling.calendarSyncs.resume('cs_abc123');
+         * console.log(sync.attributes?.status); // "active"
+         * ```
+         */
+        resume: (id: string, options?: RequestOptions) => Promise<SchedulingCalendarSync>;
+    };
+    /** Session Notes — clinical notes per appointment (Chartless-specific, backed by DataStore). */
+    sessionNotes: {
+        get: (eventId: string, noteType: import("./session-notes").SessionNoteType, workspaceId: string, options?: RequestOptions) => Promise<import("../_internal/types.gen").DataStoreRecord | null>;
+        upsert: (eventId: string, noteType: import("./session-notes").SessionNoteType, workspaceId: string, value: import("./session-notes").SessionNoteValue, options?: RequestOptions) => Promise<import("../_internal/types.gen").DataStoreRecord>;
+    };
+};
+//# sourceMappingURL=scheduling.d.ts.map