@atzentis/booking-sdk 0.1.4 → 0.1.6

package/dist/index.d.cts

@@ -94,6 +94,277 @@ declare class HttpClient {
     private buildHeaders;
 }
 
+/**
+ * All supported space types in the v4.0 API.
+ *
+ * Grouped by vertical:
+ * - **Stays:** `room`, `sunbed`, `parking`
+ * - **Tables:** `table`, `locker`
+ * - **Services:** `service`, `meeting_room`, `desk`
+ * - **Universal:** `custom`
+ */
+type SpaceType = "room" | "table" | "sunbed" | "parking" | "desk" | "meeting_room" | "locker" | "service" | "custom";
+/** All 9 space types as a readonly tuple for runtime enumeration */
+declare const SPACE_TYPES: readonly ["room", "table", "sunbed", "parking", "desk", "meeting_room", "locker", "service", "custom"];
+/** Space availability/lifecycle status */
+type SpaceStatus = "available" | "occupied" | "maintenance" | "blocked" | "inactive";
+/** All 5 space statuses as a readonly tuple for runtime enumeration */
+declare const SPACE_STATUSES: readonly ["available", "occupied", "maintenance", "blocked", "inactive"];
+/** A bookable space in the Atzentis Booking system */
+interface Space {
+    id: string;
+    propertyId: string;
+    categoryId: string | null;
+    name: string;
+    type: SpaceType;
+    status: SpaceStatus;
+    /** Used for rooms (hotel floor) and desks/meeting rooms (office floor). Use string to support labels like "B1", "G", "1", "2". */
+    floor: string | null;
+    /** Used for tables (cover count) and meeting rooms (person count). Null if not applicable. */
+    capacity: number | null;
+    /** POS table reference; set via `linkPosTable()`. Tables vertical only. Null until linked. */
+    posTableId: string | null;
+    /** Open bag for vertical-specific extras not covered by standard fields. Schema is consumer-defined. */
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Input for creating a new space */
+interface CreateSpaceInput {
+    propertyId: string;
+    name: string;
+    type: SpaceType;
+    categoryId?: string;
+    /** Optional. See `Space.floor` for usage by vertical. */
+    floor?: string;
+    /** Optional. See `Space.capacity` for usage by vertical. */
+    capacity?: number;
+    /** Optional. See `Space.metadata` for usage by vertical. */
+    metadata?: Record<string, unknown>;
+}
+/** Input for updating an existing space — all fields optional */
+type UpdateSpaceInput = Partial<Omit<CreateSpaceInput, "propertyId">>;
+/** Input for bulk updating spaces — requires `id` to identify each space */
+type BulkUpdateSpaceInput = UpdateSpaceInput & {
+    id: string;
+};
+/** Input for linking a space to a POS table */
+interface LinkPosTableInput {
+    posTableId: string;
+}
+/** Query parameters for listing spaces — propertyId is required */
+interface ListSpacesParams {
+    propertyId: string;
+    type?: SpaceType;
+    status?: SpaceStatus;
+    categoryId?: string;
+    floor?: number | string;
+    limit?: number;
+    cursor?: string;
+}
+
+/** Parameters for checking availability of a specific property */
+interface AvailabilityCheckParams {
+    /** Property to check availability for */
+    propertyId: string;
+    /** Check-in date in YYYY-MM-DD format */
+    checkIn: string;
+    /** Check-out date in YYYY-MM-DD format */
+    checkOut: string;
+    /** Filter by space category */
+    categoryId?: string;
+    /** Check a specific space */
+    spaceId?: string;
+    /** Number of guests */
+    guests?: number;
+    /** Filter by space type */
+    type?: SpaceType;
+}
+/** Result of an availability check */
+interface AvailabilityResult {
+    /** Whether any spaces are available for the requested dates */
+    available: boolean;
+    /** Available spaces matching the criteria */
+    spaces: AvailableSpace[];
+    /** Pricing details for the available spaces, null if not available */
+    pricing: AvailabilityPricing | null;
+    /** Stay restrictions, null if none apply */
+    restrictions: AvailabilityRestrictions | null;
+}
+/** A single available space from an availability check */
+interface AvailableSpace {
+    /** Space identifier */
+    spaceId: string;
+    /** Category the space belongs to */
+    categoryId: string | null;
+    /** Display name of the space */
+    name: string;
+    /** Space type (room, table, service, etc.) */
+    type: SpaceType;
+    /** Price in cents */
+    price: number;
+    /** Whether this specific space is available */
+    available: boolean;
+}
+/** Pricing breakdown from an availability check */
+interface AvailabilityPricing {
+    /** Total price in cents */
+    total: number;
+    /** Per-night rate in cents, null for non-Stays verticals */
+    perNight: number | null;
+    /** ISO 4217 currency code (e.g., "EUR", "USD") */
+    currency: string;
+}
+/** Stay restriction rules */
+interface AvailabilityRestrictions {
+    /** Minimum stay duration in nights */
+    minStay: number | null;
+    /** Maximum stay duration in nights */
+    maxStay: number | null;
+    /** Whether arrivals are blocked on this date */
+    closedToArrival: boolean;
+    /** Whether departures are blocked on this date */
+    closedToDeparture: boolean;
+}
+/** Parameters for searching availability across multiple properties */
+interface AvailabilitySearchParams {
+    /** Property IDs to search across */
+    propertyIds: string[];
+    /** Check-in date in YYYY-MM-DD format */
+    checkIn: string;
+    /** Check-out date in YYYY-MM-DD format */
+    checkOut: string;
+    /** Number of guests */
+    guests?: number;
+    /** Filter by space type */
+    type?: SpaceType;
+    /** Price range filter */
+    priceRange?: PriceRange;
+    /** Filter by category IDs */
+    categoryIds?: string[];
+    /** Maximum results per page */
+    limit?: number;
+    /** Pagination cursor */
+    cursor?: string;
+}
+/** Price range filter with min/max in cents */
+interface PriceRange {
+    /** Minimum price in cents */
+    min?: number;
+    /** Maximum price in cents */
+    max?: number;
+}
+/** Result of a multi-property availability search */
+interface AvailabilitySearchResult {
+    /** Matching properties with availability */
+    results: AvailabilitySearchResultEntry[];
+    /** Total number of matching properties */
+    totalCount: number;
+    /** Cursor for next page, null if no more results */
+    cursor: string | null;
+    /** Whether more results are available */
+    hasMore: boolean;
+}
+/** A single property's availability in a search result */
+interface AvailabilitySearchResultEntry {
+    /** Property identifier */
+    propertyId: string;
+    /** Available spaces at this property */
+    spaces: AvailableSpace[];
+    /** Lowest price in cents among available spaces */
+    bestPrice: number;
+}
+/** Parameters for generating a calendar view */
+interface CalendarParams extends AvailabilityCheckParams {
+    /** Number of months to generate (default: 1). Each month is 30 days. */
+    months?: number;
+}
+/** A single day in a calendar view */
+interface CalendarDay {
+    /** Date in YYYY-MM-DD format */
+    date: string;
+    /** Whether spaces are available on this date */
+    available: boolean;
+    /** Price in cents for this date, null if unavailable */
+    price: number | null;
+    /** Minimum stay requirement in nights, null if none */
+    minStay: number | null;
+    /** Whether arrivals are blocked on this date */
+    closedToArrival: boolean;
+    /** Whether departures are blocked on this date */
+    closedToDeparture: boolean;
+    /** Number of spaces available on this date */
+    spacesAvailable: number;
+}
+/** Parameters for querying table time slots */
+interface TableSlotParams {
+    /** Property to query */
+    propertyId: string;
+    /** Date to check in YYYY-MM-DD format */
+    date: string;
+    /** Number of guests (filters by table capacity) */
+    guests?: number;
+    /** Filter by table category (e.g., indoor, outdoor) */
+    categoryId?: string;
+    /** Reservation duration in minutes (default: 90) */
+    duration?: number;
+}
+/** Parameters for querying service appointment slots */
+interface ServiceSlotParams {
+    /** Property to query */
+    propertyId: string;
+    /** Date to check in YYYY-MM-DD format */
+    date: string;
+    /** Filter by specific provider/staff member */
+    providerId?: string;
+    /** Filter by service category */
+    categoryId?: string;
+    /** Appointment duration in minutes */
+    duration?: number;
+}
+/** A time slot for table reservations */
+interface TimeSlot {
+    /** Start time in HH:MM format (24-hour) */
+    startTime: string;
+    /** End time in HH:MM format (24-hour) */
+    endTime: string;
+    /** Whether this slot is available */
+    available: boolean;
+    /** Number of tables available in this slot */
+    tablesAvailable: number;
+    /** Price in cents for this slot, null if not priced */
+    price: number | null;
+}
+/** A time slot for service appointments, extends TimeSlot with provider info */
+interface ServiceTimeSlot extends TimeSlot {
+    /** Provider/staff member identifier */
+    providerId: string;
+    /** Display name of the provider */
+    providerName: string;
+}
+/** Parameters for pricing aggregation */
+interface PricingParams extends AvailabilityCheckParams {
+    /** ISO 4217 currency code override (default: property currency) */
+    currency?: string;
+}
+/** Aggregated pricing statistics */
+interface PricingResult {
+    /** Lowest price in cents among available spaces */
+    minPrice: number;
+    /** Highest price in cents among available spaces */
+    maxPrice: number;
+    /** Mean price in cents (rounded to integer) */
+    averagePrice: number;
+    /** Total price in cents for the full stay/booking */
+    totalPrice: number;
+    /** Per-night rate in cents, null for Tables/Services */
+    perNight: number | null;
+    /** Number of nights (date difference), 0 for same-day */
+    nights: number;
+    /** ISO 4217 currency code */
+    currency: string;
+}
+
 /** The standard paginated response shape returned by all v4.0 list endpoints */
 interface Paginated<T> {
     /** The items for this page */
@@ -113,6 +384,632 @@ interface PaginationOptions {
 /** Callback type: a function that fetches one page given current cursor options */
 type PageFetcher<T> = (options: PaginationOptions) => Promise<Paginated<T>>;
 
+/**
+ * Abstract base class for all SDK services.
+ * Provides typed HTTP helper methods and path construction.
+ * Not exported from the public API.
+ */
+declare abstract class BaseService {
+    protected readonly http: HttpClient;
+    protected abstract readonly basePath: string;
+    constructor(http: HttpClient);
+    /** Build a full path from the base path and additional segments */
+    protected _buildPath(...segments: string[]): string;
+    /** GET request returning typed response */
+    protected _get<T>(path: string, query?: Record<string, string | number | boolean | null | undefined>): Promise<T>;
+    /** POST request with body, returning typed response */
+    protected _post<T>(path: string, body: unknown): Promise<T>;
+    /** PATCH request with body, returning typed response */
+    protected _patch<T>(path: string, body: unknown): Promise<T>;
+    /** DELETE request, returning void */
+    protected _delete(path: string): Promise<void>;
+    /** GET list request with optional query params, returning paginated response */
+    protected _list<T>(params?: any): Promise<Paginated<T>>;
+}
+
+/**
+ * Service for checking and searching availability in the Atzentis Booking API.
+ *
+ * Provides two API endpoints (`check` and `search`) plus four client-side helper
+ * methods for calendar views, table time-slots, service appointment slots, and
+ * pricing aggregation.
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // Check availability for a property
+ * const result = await booking.availability.check({
+ *   propertyId: "prop_abc123",
+ *   checkIn: "2025-06-01",
+ *   checkOut: "2025-06-05",
+ * });
+ * ```
+ */
+declare class AvailabilityService extends BaseService {
+    protected readonly basePath = "/booking/v1/availability";
+    /**
+     * Check availability for a property and date range.
+     *
+     * @param params - Must include `propertyId`, `checkIn`, `checkOut`; supports optional filters
+     *
+     * @example
+     * ```typescript
+     * const result = await booking.availability.check({
+     *   propertyId: "prop_abc123",
+     *   checkIn: "2025-06-01",
+     *   checkOut: "2025-06-05",
+     *   type: "room",
+     *   guests: 2,
+     * });
+     * ```
+     */
+    check(params: AvailabilityCheckParams): Promise<AvailabilityResult>;
+    /**
+     * Search availability across multiple properties.
+     *
+     * @param params - Must include `propertyIds`, `checkIn`, `checkOut`; supports filtering and pagination
+     *
+     * @example
+     * ```typescript
+     * const results = await booking.availability.search({
+     *   propertyIds: ["prop_abc", "prop_def"],
+     *   checkIn: "2025-06-01",
+     *   checkOut: "2025-06-05",
+     *   guests: 2,
+     *   priceRange: { min: 5000, max: 20000 },
+     * });
+     * ```
+     */
+    search(params: AvailabilitySearchParams): Promise<AvailabilitySearchResult>;
+    /**
+     * Generate a calendar view of daily availability for a property.
+     *
+     * Client-side helper that calls `check()` internally and transforms the result
+     * into a `CalendarDay[]` suitable for calendar UI rendering.
+     *
+     * @param params - Extends `AvailabilityCheckParams` with optional `months` (default: 1)
+     *
+     * @example
+     * ```typescript
+     * const calendar = await booking.availability.getCalendar({
+     *   propertyId: "prop_abc123",
+     *   checkIn: "2025-06-01",
+     *   checkOut: "2025-06-30",
+     * });
+     * ```
+     */
+    getCalendar(params: CalendarParams): Promise<CalendarDay[]>;
+    /**
+     * Get available table reservation time slots for a specific date.
+     *
+     * Client-side helper for the Tables vertical. Calls `check()` internally
+     * with `type: "table"` and reshapes the response into `TimeSlot[]`.
+     *
+     * @param params - Must include `propertyId` and `date`
+     *
+     * @example
+     * ```typescript
+     * const slots = await booking.availability.getTableSlots({
+     *   propertyId: "prop_abc123",
+     *   date: "2025-06-15",
+     *   guests: 4,
+     * });
+     * ```
+     */
+    getTableSlots(params: TableSlotParams): Promise<TimeSlot[]>;
+    /**
+     * Get available service appointment slots for a specific date.
+     *
+     * Client-side helper for the Services vertical. Calls `check()` internally
+     * with `type: "service"` and reshapes the response into `ServiceTimeSlot[]`.
+     *
+     * @param params - Must include `propertyId` and `date`
+     *
+     * @example
+     * ```typescript
+     * const slots = await booking.availability.getServiceSlots({
+     *   propertyId: "prop_abc123",
+     *   date: "2025-06-15",
+     *   providerId: "staff_001",
+     *   duration: 60,
+     * });
+     * ```
+     */
+    getServiceSlots(params: ServiceSlotParams): Promise<ServiceTimeSlot[]>;
+    /**
+     * Get aggregated pricing statistics for a property and date range.
+     *
+     * Client-side helper that calls `check()` internally and computes
+     * min/max/average/total pricing from available spaces.
+     *
+     * @param params - Extends `AvailabilityCheckParams` with optional `currency`
+     *
+     * @example
+     * ```typescript
+     * const pricing = await booking.availability.getPricing({
+     *   propertyId: "prop_abc123",
+     *   checkIn: "2025-06-01",
+     *   checkOut: "2025-06-05",
+     * });
+     * console.log(`From €${pricing.minPrice / 100} to €${pricing.maxPrice / 100}`);
+     * ```
+     */
+    getPricing(params: PricingParams): Promise<PricingResult>;
+}
+
+/**
+ * All supported booking types across the three verticals.
+ *
+ * - **Stays:** `stay`, `dayuse`
+ * - **Tables:** `table`
+ * - **Services:** `service`
+ * - **Universal:** `parking`, `desk`, `meeting`, `custom`
+ */
+type BookingType = "stay" | "table" | "service" | "parking" | "desk" | "meeting" | "dayuse" | "custom";
+/** All 8 booking types as a readonly tuple for runtime enumeration */
+declare const BOOKING_TYPES: readonly ["stay", "table", "service", "parking", "desk", "meeting", "dayuse", "custom"];
+/**
+ * Booking lifecycle statuses.
+ *
+ * State machine:
+ * ```
+ * pending ──→ confirmed ──→ checked_in ──→ checked_out
+ *    │             │              │
+ *    ├─→ cancelled ├─→ cancelled  ├─→ cancelled
+ *    ├─→ waitlist   └─→ no_show   └─→ no_show
+ *    └─→ no_show
+ * ```
+ */
+type BookingStatus = "pending" | "confirmed" | "checked_in" | "checked_out" | "cancelled" | "no_show" | "waitlist";
+/** All 7 booking statuses as a readonly tuple for runtime enumeration */
+declare const BOOKING_STATUSES: readonly ["pending", "confirmed", "checked_in", "checked_out", "cancelled", "no_show", "waitlist"];
+/** Guest summary embedded in a booking */
+interface BookingGuest {
+    /** Guest identifier */
+    id: string;
+    /** Guest first name */
+    firstName: string;
+    /** Guest last name */
+    lastName: string;
+    /** Guest email address */
+    email: string | null;
+    /** Guest phone number */
+    phone: string | null;
+}
+/** Space summary embedded in a booking */
+interface BookingSpace {
+    /** Space identifier */
+    id: string;
+    /** Display name of the space */
+    name: string;
+    /** Space type (room, table, service, etc.) */
+    type: SpaceType;
+    /** Category the space belongs to */
+    categoryId: string | null;
+    /** Floor the space is on */
+    floor: string | null;
+}
+/** Pricing breakdown for a booking */
+interface BookingPricing {
+    /** Total price in cents */
+    total: number;
+    /** Per-night rate in cents, null for non-Stays verticals */
+    perNight: number | null;
+    /** ISO 4217 currency code (e.g., "EUR", "USD") */
+    currency: string;
+    /** Tax amount in cents */
+    taxes: number;
+    /** Fee amount in cents */
+    fees: number;
+}
+/** A booking in the Atzentis Booking system */
+interface Booking {
+    /** Booking identifier */
+    id: string;
+    /** Human-readable confirmation code */
+    confirmationCode: string;
+    /** Property this booking belongs to */
+    propertyId: string;
+    /** Category for the booked space */
+    categoryId: string | null;
+    /** Guest who made the booking */
+    guestId: string;
+    /** Assigned space, null until assigned */
+    spaceId: string | null;
+    /** Booking type */
+    type: BookingType;
+    /** Current lifecycle status */
+    status: BookingStatus;
+    /** Check-in date in YYYY-MM-DD format */
+    checkIn: string;
+    /** Check-out date in YYYY-MM-DD format */
+    checkOut: string;
+    /** Number of guests */
+    guests: number;
+    /** Free-text notes */
+    notes: string | null;
+    /** Booking source (e.g., "website", "phone", "walk-in") */
+    source: string | null;
+    /** Rate plan identifier */
+    rateId: string | null;
+    /** Open bag for custom data */
+    metadata: Record<string, unknown> | null;
+    /** Guest summary */
+    guest: BookingGuest | null;
+    /** Assigned space summary */
+    space: BookingSpace | null;
+    /** Pricing breakdown */
+    pricing: BookingPricing | null;
+    /** When the booking was confirmed */
+    confirmedAt: string | null;
+    /** When the guest checked in */
+    checkedInAt: string | null;
+    /** When the guest checked out */
+    checkedOutAt: string | null;
+    /** When the booking was cancelled */
+    cancelledAt: string | null;
+    /** Cancellation reason, populated on cancel */
+    cancellationReason: string | null;
+    /** When the booking was marked as no-show */
+    noShowAt: string | null;
+    /** Record creation timestamp */
+    createdAt: string;
+    /** Record last-update timestamp */
+    updatedAt: string;
+}
+/** Input for creating a new booking */
+interface CreateBookingInput {
+    /** Property to create the booking for */
+    propertyId: string;
+    /** Category for the booked space */
+    categoryId: string;
+    /** Guest identifier */
+    guestId: string;
+    /** Check-in date in YYYY-MM-DD format */
+    checkIn: string;
+    /** Check-out date in YYYY-MM-DD format */
+    checkOut: string;
+    /** Booking type */
+    type: BookingType;
+    /** Number of guests */
+    guests?: number;
+    /** Assign a specific space */
+    spaceId?: string;
+    /** Free-text notes */
+    notes?: string;
+    /** Booking source */
+    source?: string;
+    /** Rate plan identifier */
+    rateId?: string;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+    /** Auto-confirm the booking on creation */
+    autoConfirm?: boolean;
+}
+/** Input for updating an existing booking — all fields optional */
+interface UpdateBookingInput {
+    /** Update the category */
+    categoryId?: string;
+    /** Update check-in date */
+    checkIn?: string;
+    /** Update check-out date */
+    checkOut?: string;
+    /** Update number of guests */
+    guests?: number;
+    /** Update notes */
+    notes?: string;
+    /** Update source */
+    source?: string;
+    /** Update rate plan */
+    rateId?: string;
+    /** Update metadata */
+    metadata?: Record<string, unknown>;
+}
+/** Input for check-in operation */
+interface CheckInInput {
+    /** Actual arrival time in ISO 8601 format */
+    actualArrival?: string;
+    /** Check-in notes */
+    notes?: string;
+    /** Assign or change space at check-in */
+    spaceId?: string;
+}
+/** Input for check-out operation */
+interface CheckOutInput {
+    /** Actual departure time in ISO 8601 format */
+    actualDeparture?: string;
+    /** Check-out notes */
+    notes?: string;
+}
+/** Input for cancel operation */
+interface CancelBookingInput {
+    /** Cancellation reason (required) */
+    reason: string;
+    /** Who cancelled the booking */
+    cancelledBy?: string;
+    /** Whether a refund was requested */
+    refundRequested?: boolean;
+}
+/** Input for no-show operation */
+interface NoShowInput {
+    /** No-show notes */
+    notes?: string;
+    /** Whether to charge a no-show fee */
+    chargeNoShowFee?: boolean;
+}
+/** Input for space assignment */
+interface AssignSpaceInput {
+    /** Space to assign (required) */
+    spaceId: string;
+    /** Assignment notes */
+    notes?: string;
+}
+/** Sort configuration for booking list queries */
+interface BookingSort {
+    /** Field to sort by */
+    field: "checkIn" | "checkOut" | "createdAt" | "updatedAt" | "status";
+    /** Sort direction */
+    direction: "asc" | "desc";
+}
+/** Query parameters for listing bookings */
+interface ListBookingsParams {
+    /** Property to list bookings for (required) */
+    propertyId: string;
+    /** Filter by status (single or array) */
+    status?: BookingStatus | BookingStatus[];
+    /** Filter by type (single or array) */
+    type?: BookingType | BookingType[];
+    /** Filter by guest */
+    guestId?: string;
+    /** Filter by check-in date (from) */
+    checkInFrom?: string;
+    /** Filter by check-in date (to) */
+    checkInTo?: string;
+    /** Filter by check-out date (from) */
+    checkOutFrom?: string;
+    /** Filter by check-out date (to) */
+    checkOutTo?: string;
+    /** Search by confirmation code or guest name */
+    search?: string;
+    /** Sort configuration */
+    sort?: BookingSort;
+    /** Maximum results per page */
+    limit?: number;
+    /** Pagination cursor */
+    cursor?: string;
+}
+/** Paginated list of bookings */
+interface PaginatedBookings {
+    /** Bookings in this page */
+    data: Booking[];
+    /** Total number of matching bookings */
+    totalCount: number;
+    /** Cursor for next page, null if no more results */
+    cursor: string | null;
+    /** Whether more results are available */
+    hasMore: boolean;
+}
+
+/**
+ * Service for managing bookings in the Atzentis Booking API.
+ *
+ * Provides full CRUD operations and lifecycle management across all
+ * 8 booking types (stay, table, service, parking, desk, meeting, dayuse, custom)
+ * and 7 statuses (pending, confirmed, checked_in, checked_out, cancelled, no_show, waitlist).
+ *
+ * **Lifecycle state machine:**
+ * ```
+ * pending ──→ confirmed ──→ checked_in ──→ checked_out
+ *    │             │              │
+ *    ├─→ cancelled ├─→ cancelled  ├─→ cancelled
+ *    ├─→ waitlist   └─→ no_show   └─→ no_show
+ *    └─→ no_show
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // Create a stay booking
+ * const newBooking = await booking.bookings.create({
+ *   propertyId: "prop_abc123",
+ *   categoryId: "cat_deluxe",
+ *   guestId: "guest_42",
+ *   checkIn: "2025-07-01",
+ *   checkOut: "2025-07-05",
+ *   type: "stay",
+ * });
+ *
+ * // Lifecycle: confirm → check-in → check-out
+ * await booking.bookings.confirm(newBooking.id);
+ * await booking.bookings.checkIn(newBooking.id);
+ * await booking.bookings.checkOut(newBooking.id);
+ * ```
+ */
+declare class BookingsService extends BaseService {
+    protected readonly basePath = "/booking/v1/bookings";
+    /**
+     * Create a new booking.
+     *
+     * @example
+     * ```typescript
+     * const booking = await client.bookings.create({
+     *   propertyId: "prop_abc123",
+     *   categoryId: "cat_deluxe",
+     *   guestId: "guest_42",
+     *   checkIn: "2025-07-01",
+     *   checkOut: "2025-07-05",
+     *   type: "stay",
+     *   guests: 2,
+     *   autoConfirm: true,
+     * });
+     * ```
+     */
+    create(input: CreateBookingInput): Promise<Booking>;
+    /**
+     * Get a single booking by ID.
+     *
+     * @example
+     * ```typescript
+     * const booking = await client.bookings.get("bk_abc123");
+     * ```
+     */
+    get(bookingId: string): Promise<Booking>;
+    /**
+     * List bookings for a property with optional filters and cursor-based pagination.
+     *
+     * Supports filtering by status, type, guest, date ranges, search term,
+     * and custom sort order. Array values for `status` and `type` are serialized
+     * as comma-separated strings.
+     *
+     * @example
+     * ```typescript
+     * // List all confirmed stay bookings
+     * const page = await client.bookings.list({
+     *   propertyId: "prop_abc123",
+     *   status: "confirmed",
+     *   type: "stay",
+     * });
+     *
+     * // Multi-status filter with date range
+     * const page2 = await client.bookings.list({
+     *   propertyId: "prop_abc123",
+     *   status: ["confirmed", "checked_in"],
+     *   checkInFrom: "2025-07-01",
+     *   checkInTo: "2025-07-31",
+     *   sort: { field: "checkIn", direction: "asc" },
+     *   limit: 20,
+     * });
+     * ```
+     */
+    list(params: ListBookingsParams): Promise<PaginatedBookings>;
+    /**
+     * Update an existing booking.
+     *
+     * @example
+     * ```typescript
+     * const updated = await client.bookings.update("bk_abc123", {
+     *   guests: 3,
+     *   notes: "Extra bed requested",
+     * });
+     * ```
+     */
+    update(bookingId: string, input: UpdateBookingInput): Promise<Booking>;
+    /**
+     * Delete a booking.
+     *
+     * @example
+     * ```typescript
+     * await client.bookings.delete("bk_abc123");
+     * ```
+     */
+    delete(bookingId: string): Promise<void>;
+    /**
+     * Confirm a pending booking.
+     *
+     * Transitions: `pending` → `confirmed`
+     *
+     * @throws {ConflictError} 409 if the booking is not in `pending` status
+     *
+     * @example
+     * ```typescript
+     * const confirmed = await client.bookings.confirm("bk_abc123");
+     * // confirmed.status === "confirmed"
+     * // confirmed.confirmedAt is populated
+     * ```
+     */
+    confirm(bookingId: string): Promise<Booking>;
+    /**
+     * Check in a guest.
+     *
+     * Transitions: `confirmed` → `checked_in`
+     *
+     * @throws {ConflictError} 409 if the booking is not in `confirmed` status
+     *
+     * @example
+     * ```typescript
+     * const checkedIn = await client.bookings.checkIn("bk_abc123", {
+     *   actualArrival: "2025-07-01T14:30:00Z",
+     * });
+     * // checkedIn.status === "checked_in"
+     * // checkedIn.checkedInAt is populated
+     * ```
+     */
+    checkIn(bookingId: string, input?: CheckInInput): Promise<Booking>;
+    /**
+     * Check out a guest.
+     *
+     * Transitions: `checked_in` → `checked_out`
+     *
+     * @throws {ConflictError} 409 if the booking is not in `checked_in` status
+     *
+     * @example
+     * ```typescript
+     * const checkedOut = await client.bookings.checkOut("bk_abc123", {
+     *   actualDeparture: "2025-07-05T11:00:00Z",
+     * });
+     * // checkedOut.status === "checked_out"
+     * // checkedOut.checkedOutAt is populated
+     * ```
+     */
+    checkOut(bookingId: string, input?: CheckOutInput): Promise<Booking>;
+    /**
+     * Cancel a booking.
+     *
+     * Transitions: `pending` | `confirmed` | `checked_in` → `cancelled`
+     *
+     * @throws {ConflictError} 409 if the booking is already cancelled, checked out, or no-show
+     *
+     * @example
+     * ```typescript
+     * const cancelled = await client.bookings.cancel("bk_abc123", {
+     *   reason: "Guest requested cancellation",
+     *   refundRequested: true,
+     * });
+     * // cancelled.status === "cancelled"
+     * // cancelled.cancelledAt is populated
+     * // cancelled.cancellationReason === "Guest requested cancellation"
+     * ```
+     */
+    cancel(bookingId: string, input: CancelBookingInput): Promise<Booking>;
+    /**
+     * Mark a booking as no-show.
+     *
+     * Transitions: `pending` | `confirmed` | `checked_in` → `no_show`
+     *
+     * @throws {ConflictError} 409 if the booking is already checked out, cancelled, or no-show
+     *
+     * @example
+     * ```typescript
+     * const noShow = await client.bookings.noShow("bk_abc123", {
+     *   chargeNoShowFee: true,
+     * });
+     * // noShow.status === "no_show"
+     * // noShow.noShowAt is populated
+     * ```
+     */
+    noShow(bookingId: string, input?: NoShowInput): Promise<Booking>;
+    /**
+     * Assign or reassign a space to a booking.
+     *
+     * Can be called on any active booking (pending, confirmed, checked_in).
+     *
+     * @throws {ConflictError} 409 if the booking is in a terminal status
+     *
+     * @example
+     * ```typescript
+     * const assigned = await client.bookings.assignSpace("bk_abc123", {
+     *   spaceId: "spc_room101",
+     *   notes: "Upgraded to deluxe",
+     * });
+     * // assigned.spaceId === "spc_room101"
+     * // assigned.space is populated
+     * ```
+     */
+    assignSpace(bookingId: string, input: AssignSpaceInput): Promise<Booking>;
+}
+
 /** All supported property types in the v4.0 API */
 type PropertyType = "hotel" | "resort" | "villa" | "apartment" | "hostel" | "bnb" | "restaurant" | "cafe" | "bar" | "beach" | "spa" | "salon" | "custom";
 /** Property lifecycle status */
@@ -225,29 +1122,6 @@ interface ListCategoriesParams {
     limit?: number;
 }
 
-/**
- * Abstract base class for all SDK services.
- * Provides typed HTTP helper methods and path construction.
- * Not exported from the public API.
- */
-declare abstract class BaseService {
-    protected readonly http: HttpClient;
-    protected abstract readonly basePath: string;
-    constructor(http: HttpClient);
-    /** Build a full path from the base path and additional segments */
-    protected _buildPath(...segments: string[]): string;
-    /** GET request returning typed response */
-    protected _get<T>(path: string, query?: Record<string, string | number | boolean | null | undefined>): Promise<T>;
-    /** POST request with body, returning typed response */
-    protected _post<T>(path: string, body: unknown): Promise<T>;
-    /** PATCH request with body, returning typed response */
-    protected _patch<T>(path: string, body: unknown): Promise<T>;
-    /** DELETE request, returning void */
-    protected _delete(path: string): Promise<void>;
-    /** GET list request with optional query params, returning paginated response */
-    protected _list<T>(params?: any): Promise<Paginated<T>>;
-}
-
 /**
  * Service for managing space categories (room types) in the Atzentis Booking API.
  *
@@ -402,75 +1276,6 @@ declare class PropertiesService extends BaseService {
     delete(propertyId: string): Promise<void>;
 }
 
-/**
- * All supported space types in the v4.0 API.
- *
- * Grouped by vertical:
- * - **Stays:** `room`, `sunbed`, `parking`
- * - **Tables:** `table`, `locker`
- * - **Services:** `service`, `meeting_room`, `desk`
- * - **Universal:** `custom`
- */
-type SpaceType = "room" | "table" | "sunbed" | "parking" | "desk" | "meeting_room" | "locker" | "service" | "custom";
-/** All 9 space types as a readonly tuple for runtime enumeration */
-declare const SPACE_TYPES: readonly ["room", "table", "sunbed", "parking", "desk", "meeting_room", "locker", "service", "custom"];
-/** Space availability/lifecycle status */
-type SpaceStatus = "available" | "occupied" | "maintenance" | "blocked" | "inactive";
-/** All 5 space statuses as a readonly tuple for runtime enumeration */
-declare const SPACE_STATUSES: readonly ["available", "occupied", "maintenance", "blocked", "inactive"];
-/** A bookable space in the Atzentis Booking system */
-interface Space {
-    id: string;
-    propertyId: string;
-    categoryId: string | null;
-    name: string;
-    type: SpaceType;
-    status: SpaceStatus;
-    /** Used for rooms (hotel floor) and desks/meeting rooms (office floor). Use string to support labels like "B1", "G", "1", "2". */
-    floor: string | null;
-    /** Used for tables (cover count) and meeting rooms (person count). Null if not applicable. */
-    capacity: number | null;
-    /** POS table reference; set via `linkPosTable()`. Tables vertical only. Null until linked. */
-    posTableId: string | null;
-    /** Open bag for vertical-specific extras not covered by standard fields. Schema is consumer-defined. */
-    metadata: Record<string, unknown> | null;
-    createdAt: string;
-    updatedAt: string;
-}
-/** Input for creating a new space */
-interface CreateSpaceInput {
-    propertyId: string;
-    name: string;
-    type: SpaceType;
-    categoryId?: string;
-    /** Optional. See `Space.floor` for usage by vertical. */
-    floor?: string;
-    /** Optional. See `Space.capacity` for usage by vertical. */
-    capacity?: number;
-    /** Optional. See `Space.metadata` for usage by vertical. */
-    metadata?: Record<string, unknown>;
-}
-/** Input for updating an existing space — all fields optional */
-type UpdateSpaceInput = Partial<Omit<CreateSpaceInput, "propertyId">>;
-/** Input for bulk updating spaces — requires `id` to identify each space */
-type BulkUpdateSpaceInput = UpdateSpaceInput & {
-    id: string;
-};
-/** Input for linking a space to a POS table */
-interface LinkPosTableInput {
-    posTableId: string;
-}
-/** Query parameters for listing spaces — propertyId is required */
-interface ListSpacesParams {
-    propertyId: string;
-    type?: SpaceType;
-    status?: SpaceStatus;
-    categoryId?: string;
-    floor?: number | string;
-    limit?: number;
-    cursor?: string;
-}
-
 /**
  * Service for managing bookable spaces in the Atzentis Booking API.
  *
@@ -611,10 +1416,16 @@ declare class SpacesService extends BaseService {
  */
 declare class BookingClient {
     readonly httpClient: HttpClient;
+    private _availability?;
+    private _bookings?;
     private _properties?;
     private _categories?;
     private _spaces?;
     constructor(config: BookingClientConfig);
+    /** Availability service — lazy-initialized on first access */
+    get availability(): AvailabilityService;
+    /** Bookings service — lazy-initialized on first access */
+    get bookings(): BookingsService;
     /** Properties service — lazy-initialized on first access */
     get properties(): PropertiesService;
     /** Categories service — lazy-initialized on first access */
@@ -703,4 +1514,4 @@ declare function firstPage<T>(fetcher: PageFetcher<T>, options?: PaginationOptio
 
 declare const VERSION = "0.1.0";
 
-export { AuthenticationError, BookingClient, type BookingClientConfig, BookingError, type BookingErrorOptions, type BulkUpdateSpaceInput, CategoriesService, ConflictError, type Coordinates, type CreateCategoryInput, type CreatePropertyInput, type CreateSpaceInput, DEFAULT_MODULES, ForbiddenError, HttpClient, type HttpClientOptions, type HttpMethod, type HttpResponse, type LinkPosTableInput, type ListCategoriesParams, type ListPropertiesParams, type ListSpacesParams, type Logger, NotFoundError, PROPERTY_MODULES, type PageFetcher, type Paginated, type PaginationOptions, PaymentError, PropertiesService, type Property, type PropertyAddress, type PropertyModules, type PropertyStatus, type PropertyType, RateLimitError, type RequestOptions, type ResolvedBookingClientConfig, type RetryConfig, type RetryOptions, SPACE_STATUSES, SPACE_TYPES, ServerError, type Space, type SpaceCategory, type SpaceStatus, type SpaceType, SpacesService, TimeoutError, type UpdateCategoryInput, type UpdatePropertyInput, type UpdateSpaceInput, VERSION, ValidationError, bookingClientConfigSchema, createErrorFromResponse, firstPage, paginate };
+export { type AssignSpaceInput, AuthenticationError, type AvailabilityCheckParams, type AvailabilityPricing, type AvailabilityRestrictions, type AvailabilityResult, type AvailabilitySearchParams, type AvailabilitySearchResult, type AvailabilitySearchResultEntry, AvailabilityService, type AvailableSpace, BOOKING_STATUSES, BOOKING_TYPES, type Booking, BookingClient, type BookingClientConfig, BookingError, type BookingErrorOptions, type BookingGuest, type BookingPricing, type BookingSort, type BookingSpace, type BookingStatus, type BookingType, BookingsService, type BulkUpdateSpaceInput, type CalendarDay, type CalendarParams, type CancelBookingInput, CategoriesService, type CheckInInput, type CheckOutInput, ConflictError, type Coordinates, type CreateBookingInput, type CreateCategoryInput, type CreatePropertyInput, type CreateSpaceInput, DEFAULT_MODULES, ForbiddenError, HttpClient, type HttpClientOptions, type HttpMethod, type HttpResponse, type LinkPosTableInput, type ListBookingsParams, type ListCategoriesParams, type ListPropertiesParams, type ListSpacesParams, type Logger, type NoShowInput, NotFoundError, PROPERTY_MODULES, type PageFetcher, type Paginated, type PaginatedBookings, type PaginationOptions, PaymentError, type PriceRange, type PricingParams, type PricingResult, PropertiesService, type Property, type PropertyAddress, type PropertyModules, type PropertyStatus, type PropertyType, RateLimitError, type RequestOptions, type ResolvedBookingClientConfig, type RetryConfig, type RetryOptions, SPACE_STATUSES, SPACE_TYPES, ServerError, type ServiceSlotParams, type ServiceTimeSlot, type Space, type SpaceCategory, type SpaceStatus, type SpaceType, SpacesService, type TableSlotParams, type TimeSlot, TimeoutError, type UpdateBookingInput, type UpdateCategoryInput, type UpdatePropertyInput, type UpdateSpaceInput, VERSION, ValidationError, bookingClientConfigSchema, createErrorFromResponse, firstPage, paginate };