@atzentis/booking-sdk 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -1197,6 +1197,704 @@ declare class CategoriesService extends BaseService {
     delete(categoryId: string): Promise<void>;
 }
 
+/** Supported distribution channel types */
+type ChannelType = "channex" | "ical" | "direct";
+/** Channel connection status */
+type ChannelStatus = "active" | "inactive" | "error" | "pending";
+/** Credentials for channel authentication (redacted in responses) */
+type ChannelCredentials = Record<string, unknown>;
+/** Channel sync configuration */
+interface ChannelSettings {
+    autoSync?: boolean;
+    syncInterval?: number;
+    pushAvailability?: boolean;
+    pushRates?: boolean;
+    pullReservations?: boolean;
+}
+/** A distribution channel connection */
+interface Channel {
+    id: string;
+    propertyId: string;
+    type: ChannelType;
+    name: string;
+    status: ChannelStatus;
+    enabled: boolean;
+    credentials: ChannelCredentials;
+    settings: ChannelSettings;
+    lastSyncAt: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Input for creating a new channel */
+interface CreateChannelInput {
+    propertyId: string;
+    type: ChannelType;
+    name?: string;
+    enabled?: boolean;
+    credentials?: ChannelCredentials;
+    settings?: ChannelSettings;
+    metadata?: Record<string, unknown>;
+}
+/** Input for updating an existing channel */
+interface UpdateChannelInput {
+    name?: string;
+    enabled?: boolean;
+    credentials?: ChannelCredentials;
+    settings?: ChannelSettings;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing channels */
+interface ListChannelsParams {
+    propertyId?: string;
+    type?: ChannelType;
+    status?: ChannelStatus;
+    enabled?: boolean;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of channels */
+type PaginatedChannels = Paginated<Channel>;
+/** Mapping between local category and OTA room type/rate plan */
+interface ChannelMapping {
+    id: string;
+    channelId: string;
+    localCategoryId: string;
+    channelRoomTypeId: string | null;
+    channelRatePlanId: string | null;
+    settings: Record<string, unknown> | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+}
+/** Input for creating a channel mapping */
+interface CreateMappingInput {
+    localCategoryId: string;
+    channelRoomTypeId?: string;
+    channelRatePlanId?: string;
+    settings?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing mappings */
+interface ListMappingsParams {
+    localCategoryId?: string;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of channel mappings */
+type PaginatedMappings = Paginated<ChannelMapping>;
+/** Type of sync operation */
+type SyncOperationType = "push" | "pull";
+/** Status of a sync operation */
+type SyncOperationStatus = "pending" | "running" | "completed" | "failed";
+/** Statistics from a sync operation */
+interface SyncStats {
+    itemsSynced: number;
+    itemsFailed: number;
+    warnings: string[];
+}
+/** Error encountered during sync */
+interface SyncError {
+    code: string;
+    message: string;
+    details: Record<string, unknown> | null;
+}
+/** A sync operation record */
+interface SyncOperation {
+    id: string;
+    channelId: string;
+    type: SyncOperationType;
+    status: SyncOperationStatus;
+    startedAt: string | null;
+    completedAt: string | null;
+    stats: SyncStats | null;
+    errors: SyncError[];
+    createdAt: string;
+}
+/** Input for push sync */
+interface PushSyncInput {
+    dateFrom?: string;
+    dateTo?: string;
+    fullSync?: boolean;
+}
+/** Input for pull sync */
+interface PullSyncInput {
+    dateFrom?: string;
+    dateTo?: string;
+}
+/** Parameters for querying sync log */
+interface SyncLogParams {
+    type?: SyncOperationType;
+    status?: SyncOperationStatus;
+    from?: string;
+    to?: string;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated sync operation log */
+type PaginatedSyncLog = Paginated<SyncOperation>;
+/** Input for iCal import */
+interface ICalImportInput {
+    spaceId: string;
+    importUrl: string;
+    name?: string;
+    autoSync?: boolean;
+}
+/** Result of an iCal import operation */
+interface ICalImportResult {
+    id: string;
+    spaceId: string;
+    importUrl: string;
+    eventsImported: number;
+    lastImportedAt: string | null;
+    status: string;
+}
+/** Result of an iCal export operation */
+interface ICalExportResult {
+    spaceId: string;
+    exportUrl: string;
+    lastExportedAt: string | null;
+}
+
+/**
+ * Service for managing distribution channels in the Atzentis Booking API.
+ *
+ * Provides channel CRUD, mapping management, push/pull sync operations,
+ * sync log retrieval, and iCal import/export.
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // Create a Channex connection
+ * const channel = await booking.distribution.createChannel({
+ *   propertyId: "prop_abc123",
+ *   type: "channex",
+ *   name: "Booking.com via Channex",
+ * });
+ *
+ * // Push availability to channel
+ * await booking.distribution.push(channel.id, {
+ *   dateFrom: "2025-07-01",
+ *   dateTo: "2025-12-31",
+ * });
+ * ```
+ */
+declare class DistributionService extends BaseService {
+    protected readonly basePath = "/distribution/v1";
+    /** Create a new distribution channel */
+    createChannel(input: CreateChannelInput): Promise<Channel>;
+    /** Get a channel by ID */
+    getChannel(channelId: string): Promise<Channel>;
+    /** List channels with optional filters */
+    listChannels(params?: ListChannelsParams): Promise<PaginatedChannels>;
+    /** Update a channel */
+    updateChannel(channelId: string, input: UpdateChannelInput): Promise<Channel>;
+    /** Delete a channel */
+    deleteChannel(channelId: string): Promise<void>;
+    /** Create a mapping between a local category and OTA room type/rate plan */
+    createMapping(channelId: string, input: CreateMappingInput): Promise<ChannelMapping>;
+    /** List mappings for a channel */
+    listMappings(channelId: string, params?: ListMappingsParams): Promise<PaginatedMappings>;
+    /** Delete a mapping */
+    deleteMapping(channelId: string, mappingId: string): Promise<void>;
+    /** Push availability and rates to a channel */
+    push(channelId: string, input?: PushSyncInput): Promise<SyncOperation>;
+    /** Pull reservations from a channel */
+    pull(channelId: string, input?: PullSyncInput): Promise<SyncOperation>;
+    /** Get sync operation log for a channel */
+    getSyncLog(channelId: string, params?: SyncLogParams): Promise<PaginatedSyncLog>;
+    /** Import availability from an external iCal feed */
+    icalImport(input: ICalImportInput): Promise<ICalImportResult>;
+    /** Get iCal export URL for a space */
+    icalExport(spaceId: string): Promise<ICalExportResult>;
+}
+
+/** Status of a folio */
+type FolioStatus = "open" | "closed" | "settled";
+/** A guest folio (accounting record) */
+interface Folio {
+    id: string;
+    bookingId: string;
+    guestId: string | null;
+    status: FolioStatus;
+    balance: number;
+    totalCharges: number;
+    totalPayments: number;
+    currency: string;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+    closedAt: string | null;
+    settledAt: string | null;
+}
+/** Input for creating a folio */
+interface CreateFolioInput {
+    bookingId: string;
+    guestId?: string;
+    currency?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Input for updating a folio */
+interface UpdateFolioInput {
+    guestId?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing folios */
+interface ListFoliosParams {
+    bookingId?: string;
+    guestId?: string;
+    status?: FolioStatus;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of folios */
+type PaginatedFolios = Paginated<Folio>;
+/** Type of charge applied to a folio */
+type ChargeType = "room" | "minibar" | "restaurant" | "spa" | "parking" | "telephone" | "laundry" | "pos" | "other";
+/** A charge on a folio */
+interface FolioCharge {
+    id: string;
+    folioId: string;
+    type: ChargeType;
+    description: string | null;
+    amount: number;
+    currency: string;
+    transitory: boolean;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+}
+/** Input for creating a charge */
+interface CreateChargeInput {
+    type: ChargeType;
+    amount: number;
+    description?: string;
+    currency?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing charges */
+interface ListChargesParams {
+    type?: ChargeType;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of charges */
+type PaginatedCharges = Paginated<FolioCharge>;
+/** Input for moving charges between folios */
+interface MoveChargesInput {
+    chargeIds: string[];
+    toFolioId: string;
+}
+/** A payment applied to a folio */
+interface FolioPayment {
+    id: string;
+    folioId: string;
+    amount: number;
+    currency: string;
+    method: string;
+    reference: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+}
+/** Input for creating a folio payment */
+interface CreateFolioPaymentInput {
+    amount: number;
+    method: string;
+    reference?: string;
+    currency?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing folio payments */
+interface ListFolioPaymentsParams {
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of folio payments */
+type PaginatedFolioPayments = Paginated<FolioPayment>;
+/** Status of an invoice */
+type InvoiceStatus = "draft" | "finalized" | "voided";
+/** A fiscal invoice */
+interface Invoice {
+    id: string;
+    folioId: string;
+    number: string;
+    status: InvoiceStatus;
+    amount: number;
+    currency: string;
+    language: string;
+    fiscalId: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    finalizedAt: string | null;
+}
+/** Input for generating an invoice */
+interface CreateInvoiceInput {
+    language?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Daily accounting report */
+interface AccountingDailyReport {
+    date: string;
+    totalRevenue: number;
+    totalCharges: number;
+    totalPayments: number;
+    breakdown: Record<string, number>;
+}
+/** Revenue report by charge type */
+interface AccountingRevenueReport {
+    period: {
+        from: string;
+        to: string;
+    };
+    breakdown: Record<string, number>;
+}
+/** VAT breakdown entry */
+interface VatBreakdownEntry {
+    net: number;
+    vat: number;
+    gross: number;
+}
+/** VAT accounting report */
+interface AccountingVatReport {
+    period: {
+        from: string;
+        to: string;
+    };
+    breakdown: Record<string, VatBreakdownEntry>;
+}
+/** Parameters for accounting reports */
+interface AccountingReportParams {
+    date?: string;
+    from?: string;
+    to?: string;
+    propertyId?: string;
+}
+/** A line item in a POS order */
+interface FolioPostItem {
+    name: string;
+    quantity: number;
+    unitPrice: number;
+    category: string;
+}
+/** Input for posting a POS charge to a folio */
+interface FolioPostInput {
+    folioId: string;
+    posOrderId: string;
+    amount: number;
+    posTerminalId?: string;
+    items?: FolioPostItem[];
+    description?: string;
+    currency?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Result of posting a POS charge */
+interface FolioPostResult {
+    chargeId: string;
+    folioId: string;
+    posOrderId: string;
+    amount: number;
+    status: "posted";
+    postedAt: string;
+}
+/** A POS charge with full provenance metadata */
+interface FolioPostCharge {
+    chargeId: string;
+    folioId: string;
+    posOrderId: string;
+    posTerminalId: string | null;
+    amount: number;
+    description: string | null;
+    items: FolioPostItem[];
+    currency: string;
+    postedAt: string;
+    metadata: Record<string, unknown> | null;
+}
+/** Parameters for listing POS charges on a folio */
+interface ListFolioPostParams {
+    posTerminalId?: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of POS charges */
+type PaginatedFolioPostCharges = Paginated<FolioPostCharge>;
+
+/**
+ * Service for financial operations in the Atzentis Booking API.
+ *
+ * Manages the full folio lifecycle (open → close → settle), charges,
+ * folio payments, invoices (including PDF export), and accounting reports.
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // Create a folio for a booking
+ * const folio = await booking.finance.createFolio({
+ *   bookingId: "bk_abc123",
+ *   currency: "EUR",
+ * });
+ *
+ * // Add a room charge
+ * await booking.finance.createCharge(folio.id, {
+ *   type: "room",
+ *   amount: 10000,
+ * });
+ *
+ * // Close and settle
+ * await booking.finance.closeFolio(folio.id);
+ * await booking.finance.settleFolio(folio.id);
+ * ```
+ */
+declare class FinanceService extends BaseService {
+    protected readonly basePath = "/finance/v1";
+    /** Create a new folio for a booking */
+    createFolio(input: CreateFolioInput): Promise<Folio>;
+    /** Get a folio by ID */
+    getFolio(folioId: string): Promise<Folio>;
+    /** List folios with optional filters */
+    listFolios(params?: ListFoliosParams): Promise<PaginatedFolios>;
+    /** Update a folio */
+    updateFolio(folioId: string, input: UpdateFolioInput): Promise<Folio>;
+    /** Close a folio (no more charges can be added) */
+    closeFolio(folioId: string): Promise<Folio>;
+    /** Settle a folio (mark as fully paid) */
+    settleFolio(folioId: string): Promise<Folio>;
+    /** Create a charge on a folio */
+    createCharge(folioId: string, input: CreateChargeInput): Promise<FolioCharge>;
+    /** List charges on a folio */
+    listCharges(folioId: string, params?: ListChargesParams): Promise<PaginatedCharges>;
+    /** Create a transitory (non-billable) charge on a folio */
+    createTransitoryCharge(folioId: string, input: CreateChargeInput): Promise<FolioCharge>;
+    /** Move charges from one folio to another */
+    moveCharges(folioId: string, input: MoveChargesInput): Promise<{
+        moved: number;
+    }>;
+    /** Record a payment on a folio */
+    createFolioPayment(folioId: string, input: CreateFolioPaymentInput): Promise<FolioPayment>;
+    /** List payments on a folio */
+    listFolioPayments(folioId: string, params?: ListFolioPaymentsParams): Promise<PaginatedFolioPayments>;
+    /** Generate an invoice for a folio */
+    generateInvoice(folioId: string, input?: CreateInvoiceInput): Promise<Invoice>;
+    /** Get an invoice by ID */
+    getInvoice(invoiceId: string): Promise<Invoice>;
+    /** Get invoice as PDF binary data */
+    getInvoicePdf(invoiceId: string): Promise<ArrayBuffer>;
+    /** Get daily accounting report */
+    getDailyReport(params?: AccountingReportParams): Promise<AccountingDailyReport>;
+    /** Get revenue report by charge type */
+    getRevenueReport(params?: AccountingReportParams): Promise<AccountingRevenueReport>;
+    /** Get VAT accounting report */
+    getVatReport(params?: AccountingReportParams): Promise<AccountingVatReport>;
+    /** Post a POS charge to a guest folio */
+    folioPost(input: FolioPostInput): Promise<FolioPostResult>;
+    /** List POS charges on a folio */
+    listFolioPostCharges(folioId: string, params?: ListFolioPostParams): Promise<PaginatedFolioPostCharges>;
+}
+
+/** Type of group booking */
+type GroupType = "wedding" | "conference" | "corporate" | "tour" | "other";
+/** Status of a group booking */
+type GroupStatus = "tentative" | "definite" | "cancelled";
+/** A single date entry in a block with room count and rate */
+interface BlockDate {
+    date: string;
+    count: number;
+    rate: number;
+}
+/** Summary of block allocation for a group */
+interface GroupBlockSummary {
+    totalRooms: number;
+    pickedUp: number;
+    remaining: number;
+}
+/** A room block within a group booking */
+interface Block {
+    id: string;
+    groupId: string;
+    categoryId: string;
+    dates: BlockDate[];
+    totalRooms: number;
+    pickedUp: number;
+    remaining: number;
+    notes: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** A group booking entity */
+interface Group {
+    id: string;
+    propertyId: string;
+    name: string;
+    type: GroupType;
+    status: GroupStatus;
+    contactName: string | null;
+    contactEmail: string | null;
+    contactPhone: string | null;
+    checkIn: string | null;
+    checkOut: string | null;
+    cutoffDate: string | null;
+    blockSummary: GroupBlockSummary;
+    folioId: string | null;
+    notes: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Pickup data broken down by category */
+interface CategoryPickup {
+    categoryId: string;
+    categoryName: string;
+    blocked: number;
+    pickedUp: number;
+    remaining: number;
+}
+/** Pickup data broken down by date */
+interface DatePickup {
+    date: string;
+    blocked: number;
+    pickedUp: number;
+    remaining: number;
+}
+/** Pickup tracking data for a group */
+interface Pickup {
+    groupId: string;
+    totalBlocked: number;
+    totalPickedUp: number;
+    totalRemaining: number;
+    pickupPercent: number;
+    byCategory: CategoryPickup[];
+    byDate: DatePickup[];
+}
+/** Result of a block release operation */
+interface ReleaseResult {
+    groupId: string;
+    releasedCount: number;
+    remainingBlocked: number;
+    releasedAt: string;
+}
+/** Result of creating a group folio */
+interface GroupFolioResult {
+    groupId: string;
+    folioId: string;
+    status: string;
+    createdAt: string;
+}
+/** Input for creating a group booking */
+interface CreateGroupInput {
+    propertyId: string;
+    name: string;
+    type?: GroupType;
+    contactName?: string;
+    contactEmail?: string;
+    contactPhone?: string;
+    checkIn?: string;
+    checkOut?: string;
+    cutoffDate?: string;
+    notes?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Input for updating a group booking */
+interface UpdateGroupInput {
+    name?: string;
+    type?: GroupType;
+    status?: GroupStatus;
+    contactName?: string;
+    contactEmail?: string;
+    contactPhone?: string;
+    checkIn?: string;
+    checkOut?: string;
+    cutoffDate?: string;
+    notes?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Input for creating a room block */
+interface CreateBlockInput {
+    categoryId: string;
+    dates: BlockDate[];
+    notes?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Input for releasing blocks */
+interface ReleaseBlocksInput {
+    count?: number;
+    categoryId?: string;
+    notes?: string;
+}
+/** Input for creating a group folio */
+interface CreateGroupFolioInput {
+    billingName?: string;
+    billingAddress?: string;
+    notes?: string;
+}
+/** Parameters for listing groups */
+interface ListGroupsParams {
+    propertyId: string;
+    status?: GroupStatus | GroupStatus[];
+    type?: GroupType | GroupType[];
+    search?: string;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of groups */
+type PaginatedGroups = Paginated<Group>;
+
+/**
+ * Service for group booking operations in the Atzentis Booking API.
+ *
+ * Provides group CRUD, room block management, pickup tracking,
+ * block release operations, and group folio creation.
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // Create a conference group
+ * const group = await booking.groups.create({
+ *   propertyId: "prop_abc123",
+ *   name: "Tech Conference 2025",
+ *   type: "conference",
+ * });
+ *
+ * // Add a room block
+ * const block = await booking.groups.createBlock(group.id, {
+ *   categoryId: "cat_std",
+ *   dates: [
+ *     { date: "2025-09-15", count: 20, rate: 12000 },
+ *     { date: "2025-09-16", count: 20, rate: 12000 },
+ *   ],
+ * });
+ *
+ * // Track pickup and release remaining
+ * const pickup = await booking.groups.getPickup(group.id);
+ * await booking.groups.release(group.id, { count: 5 });
+ * ```
+ */
+declare class GroupsService extends BaseService {
+    protected readonly basePath = "/booking/v1/groups";
+    /** Create a group booking */
+    create(input: CreateGroupInput): Promise<Group>;
+    /** Get a group booking by ID */
+    get(groupId: string): Promise<Group>;
+    /** List group bookings with filters */
+    list(params: ListGroupsParams): Promise<PaginatedGroups>;
+    /** Update a group booking */
+    update(groupId: string, input: UpdateGroupInput): Promise<Group>;
+    /** Delete a group booking */
+    delete(groupId: string): Promise<void>;
+    /** Create a room block for a group */
+    createBlock(groupId: string, input: CreateBlockInput): Promise<Block>;
+    /** List blocks for a group */
+    listBlocks(groupId: string): Promise<Block[]>;
+    /** Get pickup tracking data for a group */
+    getPickup(groupId: string): Promise<Pickup>;
+    /** Release blocks back to inventory */
+    release(groupId: string, input?: ReleaseBlocksInput): Promise<ReleaseResult>;
+    /** Create a master folio for a group */
+    createFolio(groupId: string, input?: CreateGroupFolioInput): Promise<GroupFolioResult>;
+}
+
 /** Guest address */
 interface GuestAddress {
     /** Street address */
@@ -1772,45 +2470,564 @@ declare class GuestsService extends BaseService {
     private _buildHistoryQuery;
 }
 
-/**
- * Service for managing properties in the Atzentis Booking API.
- *
- * @example
- * ```typescript
- * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
- *
- * // List all active properties
- * const { data, hasMore } = await booking.properties.list({ status: "active" });
- *
- * // Create a new property
- * const property = await booking.properties.create({
- *   name: "Seaside Villa",
- *   type: "villa",
- *   currency: "EUR",
- *   timezone: "Europe/Athens",
- *   address: { street: "123 Coast Rd", city: "Chania", country: "GR" },
- * });
- * ```
- */
-declare class PropertiesService extends BaseService {
-    protected readonly basePath = "/inventory/v1/properties";
-    /**
-     * Create a new property.
-     *
-     * @example
-     * ```typescript
-     * const property = await booking.properties.create({
-     *   name: "Hotel Athena",
-     *   type: "hotel",
-     *   currency: "EUR",
-     *   timezone: "Europe/Athens",
-     *   address: { street: "1 Plaka St", city: "Athens", country: "GR" },
-     * });
-     * ```
-     */
-    create(input: CreatePropertyInput): Promise<Property>;
-    /**
-     * List properties with optional filters and cursor-based pagination.
+/** Housekeeping status of a space */
+type HousekeepingStatus = "dirty" | "clean" | "inspected" | "out_of_order" | "out_of_service";
+/** Occupancy status of a space */
+type OccupancyStatus = "vacant" | "occupied" | "due_out" | "due_in";
+/** Priority level for housekeeping tasks */
+type HousekeepingPriority = "normal" | "rush" | "vip";
+/** A single entry on the housekeeping board */
+interface HousekeepingBoardEntry {
+    spaceId: string;
+    spaceName: string;
+    spaceType: string;
+    floor: number;
+    status: HousekeepingStatus;
+    occupancyStatus: OccupancyStatus;
+    priority: HousekeepingPriority;
+    assignedTo: string | null;
+    notes: string | null;
+    lastStatusChange: string;
+}
+/** The housekeeping board for a property */
+interface HousekeepingBoard {
+    spaces: HousekeepingBoardEntry[];
+    propertyId: string;
+    updatedAt: string;
+}
+/** Parameters for retrieving the housekeeping board */
+interface GetBoardParams {
+    propertyId?: string;
+    floor?: number;
+    status?: HousekeepingStatus;
+    assignedTo?: string;
+}
+/** Input for updating a space's housekeeping status */
+interface UpdateSpaceStatusInput {
+    status: HousekeepingStatus;
+    notes?: string;
+    assignedTo?: string;
+    priority?: HousekeepingPriority;
+}
+/** Type of housekeeping task */
+type HousekeepingTaskType = "cleaning" | "deep_cleaning" | "turnover" | "inspection" | "maintenance" | "other";
+/** Status of a housekeeping task */
+type HousekeepingTaskStatus = "pending" | "in_progress" | "completed" | "cancelled";
+/** A housekeeping task assigned to a space */
+interface HousekeepingTask {
+    id: string;
+    spaceId: string;
+    type: HousekeepingTaskType;
+    status: HousekeepingTaskStatus;
+    description: string | null;
+    assignedTo: string | null;
+    priority: HousekeepingPriority;
+    dueAt: string | null;
+    notes: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+}
+/** Input for creating a housekeeping task */
+interface CreateHousekeepingTaskInput {
+    spaceId: string;
+    type: HousekeepingTaskType;
+    description?: string;
+    assignedTo?: string;
+    priority?: HousekeepingPriority;
+    dueAt?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Input for updating a housekeeping task */
+interface UpdateHousekeepingTaskInput {
+    status?: HousekeepingTaskStatus;
+    description?: string;
+    assignedTo?: string;
+    priority?: HousekeepingPriority;
+    dueAt?: string;
+    notes?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing housekeeping tasks */
+interface ListHousekeepingTasksParams {
+    spaceId?: string;
+    status?: HousekeepingTaskStatus;
+    type?: HousekeepingTaskType;
+    assignedTo?: string;
+    priority?: HousekeepingPriority;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of housekeeping tasks */
+type PaginatedHousekeepingTasks = Paginated<HousekeepingTask>;
+/** Status of a night audit run */
+type NightAuditStatus = "pending" | "in_progress" | "completed" | "failed";
+/** Summary statistics from a night audit run */
+interface NightAuditSummary {
+    totalChargesPosted: number;
+    totalPaymentsReconciled: number;
+    totalRevenue: number;
+    currency: string;
+    discrepancyCount: number;
+}
+/** An error that occurred during a night audit run */
+interface NightAuditError {
+    code: string;
+    message: string;
+    details: Record<string, unknown> | null;
+}
+/** A night audit run record */
+interface NightAuditRun {
+    id: string;
+    propertyId: string;
+    businessDate: string;
+    status: NightAuditStatus;
+    summary: NightAuditSummary | null;
+    startedAt: string;
+    completedAt: string | null;
+    notes: string | null;
+    errors: NightAuditError[];
+    dryRun: boolean;
+    createdAt: string;
+}
+/** Input for running a night audit */
+interface RunNightAuditInput {
+    propertyId: string;
+    businessDate?: string;
+    dryRun?: boolean;
+    notes?: string;
+}
+/** Parameters for retrieving night audit history */
+interface GetNightAuditHistoryParams {
+    propertyId?: string;
+    status?: NightAuditStatus;
+    fromDate?: string;
+    toDate?: string;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of night audit runs */
+type PaginatedNightAuditRuns = Paginated<NightAuditRun>;
+/** Revenue breakdown by category */
+interface NightAuditRevenueBreakdown {
+    category: string;
+    amount: number;
+    count: number;
+}
+/** Revenue section of a night audit report */
+interface NightAuditRevenue {
+    totalRevenue: number;
+    roomRevenue: number;
+    fbRevenue: number;
+    otherRevenue: number;
+    currency: string;
+    breakdown: NightAuditRevenueBreakdown[];
+}
+/** Occupancy statistics from a night audit */
+interface NightAuditOccupancy {
+    totalSpaces: number;
+    occupiedSpaces: number;
+    occupancyRate: number;
+    arrivals: number;
+    departures: number;
+    stayovers: number;
+    noShows: number;
+}
+/** Payment method breakdown */
+interface NightAuditPaymentMethod {
+    method: string;
+    amount: number;
+    count: number;
+}
+/** Payments section of a night audit report */
+interface NightAuditPayments {
+    totalCollected: number;
+    totalPending: number;
+    totalRefunded: number;
+    currency: string;
+    byMethod: NightAuditPaymentMethod[];
+}
+/** A discrepancy found during night audit */
+interface NightAuditDiscrepancy {
+    description: string;
+    amount: number;
+    currency: string;
+    relatedId: string | null;
+    relatedType: string | null;
+}
+/** Full night audit report with revenue, occupancy, payments, and discrepancies */
+interface NightAuditReport {
+    auditId: string;
+    propertyId: string;
+    businessDate: string;
+    revenue: NightAuditRevenue;
+    occupancy: NightAuditOccupancy;
+    payments: NightAuditPayments;
+    discrepancies: NightAuditDiscrepancy[];
+    generatedAt: string;
+}
+
+/**
+ * Service for housekeeping operations in the Atzentis Booking API.
+ *
+ * Provides board retrieval with filtering, space status updates,
+ * and housekeeping task CRUD with assignment and priority tracking.
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // Get the housekeeping board for floor 2
+ * const board = await booking.housekeeping.getBoard({ floor: 2 });
+ *
+ * // Mark a space as clean
+ * await booking.housekeeping.updateSpaceStatus("space_1", {
+ *   status: "clean",
+ *   notes: "Deep cleaned",
+ * });
+ *
+ * // Create a cleaning task
+ * await booking.housekeeping.createTask({
+ *   spaceId: "space_1",
+ *   type: "turnover",
+ *   priority: "rush",
+ * });
+ * ```
+ */
+declare class HousekeepingService extends BaseService {
+    protected readonly basePath = "/operations/v1/housekeeping";
+    /** Get the housekeeping board with optional filters */
+    getBoard(params?: GetBoardParams): Promise<HousekeepingBoard>;
+    /** Update the housekeeping status of a space */
+    updateSpaceStatus(spaceId: string, input: UpdateSpaceStatusInput): Promise<HousekeepingBoardEntry>;
+    /** Create a housekeeping task */
+    createTask(input: CreateHousekeepingTaskInput): Promise<HousekeepingTask>;
+    /** List housekeeping tasks with optional filters */
+    listTasks(params?: ListHousekeepingTasksParams): Promise<PaginatedHousekeepingTasks>;
+    /** Update a housekeeping task */
+    updateTask(taskId: string, input: UpdateHousekeepingTaskInput): Promise<HousekeepingTask>;
+}
+
+/**
+ * Service for night audit operations in the Atzentis Booking API.
+ *
+ * Supports running night audits (with optional dry-run mode),
+ * retrieving audit history, and generating detailed reports with
+ * revenue, occupancy, payment, and discrepancy breakdowns.
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // Run a night audit
+ * const audit = await booking.nightAudit.run({
+ *   propertyId: "prop_abc123",
+ * });
+ *
+ * // Dry-run to preview without committing
+ * const preview = await booking.nightAudit.run({
+ *   propertyId: "prop_abc123",
+ *   dryRun: true,
+ * });
+ *
+ * // Get the detailed report
+ * const report = await booking.nightAudit.getReport(audit.id);
+ * ```
+ */
+declare class NightAuditService extends BaseService {
+    protected readonly basePath = "/operations/v1/night-audit";
+    /** Run a night audit for a property */
+    run(input: RunNightAuditInput): Promise<NightAuditRun>;
+    /** Get night audit history with optional filters */
+    getHistory(params?: GetNightAuditHistoryParams): Promise<PaginatedNightAuditRuns>;
+    /** Get the detailed report for a completed night audit */
+    getReport(auditId: string): Promise<NightAuditReport>;
+}
+
+/** Supported payment providers */
+type PaymentProvider = "stripe" | "viva_wallet";
+/** Status of a payment */
+type PaymentStatus = "succeeded" | "pending" | "failed" | "requires_action";
+/** A processed payment */
+interface Payment {
+    id: string;
+    bookingId: string;
+    amount: number;
+    currency: string;
+    status: PaymentStatus;
+    provider: PaymentProvider;
+    providerTransactionId: string | null;
+    paymentMethodId: string | null;
+    description: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Input for processing a payment */
+interface ProcessPaymentInput {
+    bookingId: string;
+    amount: number;
+    currency: string;
+    paymentMethodId?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Status of a refund */
+type RefundStatus = "succeeded" | "pending" | "failed";
+/** A refund applied to a payment */
+interface Refund {
+    id: string;
+    paymentId: string;
+    amount: number;
+    status: RefundStatus;
+    reason: string | null;
+    createdAt: string;
+}
+/** Input for refunding a payment */
+interface RefundInput {
+    amount?: number;
+    reason?: string;
+}
+/** Type of transaction */
+type TransactionType = "payment" | "refund" | "authorization" | "capture";
+/** A financial transaction record */
+interface Transaction {
+    id: string;
+    type: TransactionType;
+    bookingId: string | null;
+    amount: number;
+    currency: string;
+    status: string;
+    provider: PaymentProvider;
+    providerTransactionId: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+}
+/** Parameters for listing transactions */
+interface ListTransactionsParams {
+    bookingId?: string;
+    status?: string;
+    provider?: PaymentProvider;
+    type?: TransactionType;
+    from?: string;
+    to?: string;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of transactions */
+type PaginatedTransactions = Paginated<Transaction>;
+/** Card details for a stored payment method */
+interface CardDetails {
+    last4: string;
+    brand: string;
+    expMonth: number;
+    expYear: number;
+}
+/** Status of a payment account (stored card) */
+type PaymentAccountStatus = "active" | "expired" | "revoked";
+/** A stored payment method (card on file) */
+interface PaymentAccount {
+    id: string;
+    paymentMethodId: string;
+    bookingId: string | null;
+    guestId: string | null;
+    card: CardDetails;
+    label: string | null;
+    status: PaymentAccountStatus;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+}
+/** Input for creating a payment account */
+interface CreatePaymentAccountInput {
+    paymentMethodId: string;
+    bookingId?: string;
+    guestId?: string;
+    label?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing payment accounts */
+interface ListPaymentAccountsParams {
+    bookingId?: string;
+    guestId?: string;
+    status?: PaymentAccountStatus;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of payment accounts */
+type PaginatedPaymentAccounts = Paginated<PaymentAccount>;
+/** Status of a pre-authorization */
+type AuthorizationStatus = "authorized" | "expired" | "captured" | "voided";
+/** A pre-authorization hold on a stored card */
+interface Authorization {
+    id: string;
+    accountId: string;
+    amount: number;
+    currency: string;
+    status: AuthorizationStatus;
+    expiresAt: string;
+    description: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+}
+/** Input for authorizing a hold */
+interface AuthorizeInput {
+    amount: number;
+    currency?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Input for capturing an authorized hold */
+interface CaptureInput {
+    amount: number;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Status of a terminal POS transaction */
+type TerminalTransactionStatus = "pending" | "authorized" | "declined" | "timeout";
+/** A POS terminal transaction */
+interface TerminalTransaction {
+    id: string;
+    terminalId: string;
+    amount: number;
+    currency: string;
+    status: TerminalTransactionStatus;
+    cardPresent: boolean;
+    bookingId: string | null;
+    description: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+}
+/** Input for terminal authorization */
+interface TerminalAuthorizeInput {
+    amount: number;
+    terminalId: string;
+    bookingId?: string;
+    description?: string;
+    currency?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Status of an IRIS bank transfer */
+type IrisTransferStatus = "initiated" | "completed" | "failed" | "expired";
+/** An IRIS instant bank transfer */
+interface IrisTransfer {
+    id: string;
+    amount: number;
+    currency: string;
+    guestId: string;
+    bookingId: string | null;
+    status: IrisTransferStatus;
+    paymentUrl: string;
+    expiresAt: string;
+    description: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    completedAt: string | null;
+}
+/** Input for initiating an IRIS transfer */
+interface IrisInitiateInput {
+    amount: number;
+    guestId: string;
+    bookingId?: string;
+    description?: string;
+    returnUrl?: string;
+    metadata?: Record<string, unknown>;
+}
+
+/**
+ * Service for payment operations in the Atzentis Booking API.
+ *
+ * Supports Stripe and Viva Wallet providers with payment processing,
+ * refunds, stored card management (authorize/capture), POS terminal
+ * operations, and IRIS Greek bank transfers.
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // Process a payment
+ * const payment = await booking.payments.process({
+ *   bookingId: "bk_abc123",
+ *   amount: 15000,
+ *   currency: "EUR",
+ * });
+ *
+ * // Partial refund
+ * const refund = await booking.payments.refund(payment.id, {
+ *   amount: 5000,
+ *   reason: "Early checkout",
+ * });
+ * ```
+ */
+declare class PaymentsService extends BaseService {
+    protected readonly basePath = "/payment/v1";
+    /** Process a payment for a booking */
+    process(input: ProcessPaymentInput): Promise<Payment>;
+    /** Refund a payment (full or partial) */
+    refund(paymentId: string, input?: RefundInput): Promise<Refund>;
+    /** Get a transaction by ID */
+    getTransaction(transactionId: string): Promise<Transaction>;
+    /** List transactions with optional filters */
+    listTransactions(params?: ListTransactionsParams): Promise<PaginatedTransactions>;
+    /** Create a payment account (store a card on file) */
+    createAccount(input: CreatePaymentAccountInput): Promise<PaymentAccount>;
+    /** Get a payment account by ID */
+    getAccount(accountId: string): Promise<PaymentAccount>;
+    /** List payment accounts with optional filters */
+    listAccounts(params?: ListPaymentAccountsParams): Promise<PaginatedPaymentAccounts>;
+    /** Delete a payment account */
+    deleteAccount(accountId: string): Promise<void>;
+    /** Authorize a hold on a stored card */
+    authorize(accountId: string, input: AuthorizeInput): Promise<Authorization>;
+    /** Capture a previously authorized hold */
+    capture(accountId: string, input: CaptureInput): Promise<Payment>;
+    /** Initiate a POS terminal payment authorization */
+    terminalAuthorize(input: TerminalAuthorizeInput): Promise<TerminalTransaction>;
+    /** Initiate an IRIS instant bank transfer */
+    irisInitiate(input: IrisInitiateInput): Promise<IrisTransfer>;
+    /** Get the status of an IRIS transfer */
+    irisStatus(transferId: string): Promise<IrisTransfer>;
+}
+
+/**
+ * Service for managing properties in the Atzentis Booking API.
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // List all active properties
+ * const { data, hasMore } = await booking.properties.list({ status: "active" });
+ *
+ * // Create a new property
+ * const property = await booking.properties.create({
+ *   name: "Seaside Villa",
+ *   type: "villa",
+ *   currency: "EUR",
+ *   timezone: "Europe/Athens",
+ *   address: { street: "123 Coast Rd", city: "Chania", country: "GR" },
+ * });
+ * ```
+ */
+declare class PropertiesService extends BaseService {
+    protected readonly basePath = "/inventory/v1/properties";
+    /**
+     * Create a new property.
+     *
+     * @example
+     * ```typescript
+     * const property = await booking.properties.create({
+     *   name: "Hotel Athena",
+     *   type: "hotel",
+     *   currency: "EUR",
+     *   timezone: "Europe/Athens",
+     *   address: { street: "1 Plaka St", city: "Athens", country: "GR" },
+     * });
+     * ```
+     */
+    create(input: CreatePropertyInput): Promise<Property>;
+    /**
+     * List properties with optional filters and cursor-based pagination.
      *
      * @example
      * ```typescript
@@ -1851,6 +3068,273 @@ declare class PropertiesService extends BaseService {
     delete(propertyId: string): Promise<void>;
 }
 
+/** Status of a rate plan */
+type RatePlanStatus = "active" | "inactive";
+/** A rate plan entity */
+interface RatePlan {
+    id: string;
+    propertyId: string;
+    categoryId: string;
+    name: string;
+    description: string | null;
+    status: RatePlanStatus;
+    baseRate: number;
+    currency: string;
+    taxInclusive: boolean;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Input for creating a rate plan */
+interface CreateRatePlanInput {
+    propertyId: string;
+    categoryId: string;
+    name: string;
+    baseRate: number;
+    description?: string;
+    currency?: string;
+    taxInclusive?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/** Input for updating a rate plan */
+interface UpdateRatePlanInput {
+    name?: string;
+    description?: string;
+    baseRate?: number;
+    status?: RatePlanStatus;
+    currency?: string;
+    taxInclusive?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing rate plans */
+interface ListRatePlansParams {
+    propertyId?: string;
+    categoryId?: string;
+    status?: RatePlanStatus;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of rate plans */
+type PaginatedRatePlans = Paginated<RatePlan>;
+/** A rate period with seasonal pricing */
+interface RatePeriod {
+    id: string;
+    planId: string;
+    name: string;
+    startDate: string;
+    endDate: string;
+    rate: number;
+    adjustmentPercent: number | null;
+    adjustmentAmount: number | null;
+    minStay: number | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Input for creating a rate period */
+interface CreateRatePeriodInput {
+    name: string;
+    startDate: string;
+    endDate: string;
+    rate: number;
+    adjustmentPercent?: number;
+    adjustmentAmount?: number;
+    minStay?: number;
+    metadata?: Record<string, unknown>;
+}
+/** Input for updating a rate period */
+interface UpdateRatePeriodInput {
+    name?: string;
+    startDate?: string;
+    endDate?: string;
+    rate?: number;
+    adjustmentPercent?: number | null;
+    adjustmentAmount?: number | null;
+    minStay?: number | null;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing rate periods */
+interface ListRatePeriodsParams {
+    fromDate?: string;
+    toDate?: string;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of rate periods */
+type PaginatedRatePeriods = Paginated<RatePeriod>;
+/** Booking restrictions on a rate plan */
+interface RateRestriction {
+    planId: string;
+    minStay: number | null;
+    maxStay: number | null;
+    closedToArrival: boolean;
+    closedToDeparture: boolean;
+    closeOutDates: string[];
+    advanceBookingMin: number | null;
+    advanceBookingMax: number | null;
+    updatedAt: string;
+}
+/** Input for updating rate restrictions */
+interface UpdateRateRestrictionInput {
+    minStay?: number | null;
+    maxStay?: number | null;
+    closedToArrival?: boolean;
+    closedToDeparture?: boolean;
+    closeOutDates?: string[];
+    advanceBookingMin?: number | null;
+    advanceBookingMax?: number | null;
+}
+/** Input for calculating a rate */
+interface CalculateRateInput {
+    propertyId: string;
+    categoryId: string;
+    checkIn: string;
+    checkOut: string;
+    planId?: string;
+    guests?: number;
+    promoCode?: string;
+}
+/** A modifier applied to a nightly rate */
+interface RateModifier {
+    name: string;
+    type: "percent" | "fixed";
+    value: number;
+}
+/** Nightly rate breakdown */
+interface NightlyRate {
+    date: string;
+    baseRate: number;
+    finalRate: number;
+    modifiers: RateModifier[];
+}
+/** An applied restriction with its status */
+interface AppliedRestriction {
+    type: string;
+    value: string | number | boolean;
+    passed: boolean;
+    message: string | null;
+}
+/** Result of a rate calculation */
+interface RateCalculation {
+    planId: string;
+    planName: string;
+    totalAmount: number;
+    currency: string;
+    nights: number;
+    averageNightlyRate: number;
+    nightlyBreakdown: NightlyRate[];
+    restrictions: AppliedRestriction[];
+    taxAmount: number | null;
+    taxInclusive: boolean;
+}
+/** Input for pushing rates to a portfolio */
+interface PushPortfolioRatesInput {
+    sourcePlanId: string;
+    targetPropertyIds: string[];
+    adjustmentPercent?: number;
+    adjustmentAmount?: number;
+    periodIds?: string[];
+}
+/** Result for a single portfolio target property */
+interface PortfolioTargetResult {
+    propertyId: string;
+    success: boolean;
+    planId: string | null;
+    error: string | null;
+}
+/** Result of a portfolio rate push operation */
+interface PortfolioRatePushResult {
+    sourcePlanId: string;
+    results: PortfolioTargetResult[];
+    totalPushed: number;
+    totalFailed: number;
+}
+/** Input for comparing portfolio rates */
+interface ComparePortfolioRatesInput {
+    portfolioId: string;
+    categoryId: string;
+    checkIn: string;
+    checkOut: string;
+}
+/** Rate data for a single property in a portfolio comparison */
+interface PortfolioPropertyRate {
+    propertyId: string;
+    propertyName: string;
+    planId: string;
+    planName: string;
+    totalAmount: number;
+    averageNightlyRate: number;
+    currency: string;
+}
+/** Result of a portfolio rate comparison */
+interface PortfolioRateComparison {
+    portfolioId: string;
+    categoryId: string;
+    checkIn: string;
+    checkOut: string;
+    properties: PortfolioPropertyRate[];
+}
+
+/**
+ * Service for rate plan management in the Atzentis Booking API.
+ *
+ * Provides rate plan CRUD, rate period management with seasonal pricing,
+ * restriction configuration, dynamic price calculation with nightly breakdown,
+ * and portfolio-wide rate push and comparison.
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // Create a rate plan
+ * const plan = await booking.ratePlans.create({
+ *   propertyId: "prop_abc123",
+ *   categoryId: "cat_std",
+ *   name: "Standard Rate",
+ *   baseRate: 15000,
+ * });
+ *
+ * // Calculate price for a stay
+ * const price = await booking.ratePlans.calculate({
+ *   propertyId: "prop_abc123",
+ *   categoryId: "cat_std",
+ *   checkIn: "2025-07-01",
+ *   checkOut: "2025-07-05",
+ * });
+ * ```
+ */
+declare class RatePlansService extends BaseService {
+    protected readonly basePath = "/rate/v1";
+    /** List rate plans with optional filters */
+    list(params?: ListRatePlansParams): Promise<PaginatedRatePlans>;
+    /** Get a rate plan by ID */
+    get(planId: string): Promise<RatePlan>;
+    /** Create a new rate plan */
+    create(input: CreateRatePlanInput): Promise<RatePlan>;
+    /** Update a rate plan */
+    update(planId: string, input: UpdateRatePlanInput): Promise<RatePlan>;
+    /** Delete a rate plan */
+    delete(planId: string): Promise<void>;
+    /** List rate periods for a plan */
+    listPeriods(planId: string, params?: ListRatePeriodsParams): Promise<PaginatedRatePeriods>;
+    /** Get a rate period by ID */
+    getPeriod(planId: string, periodId: string): Promise<RatePeriod>;
+    /** Create a rate period */
+    createPeriod(planId: string, input: CreateRatePeriodInput): Promise<RatePeriod>;
+    /** Update a rate period */
+    updatePeriod(planId: string, periodId: string, input: UpdateRatePeriodInput): Promise<RatePeriod>;
+    /** Get restrictions for a rate plan */
+    getRestrictions(planId: string): Promise<RateRestriction>;
+    /** Update restrictions for a rate plan */
+    updateRestrictions(planId: string, input: UpdateRateRestrictionInput): Promise<RateRestriction>;
+    /** Calculate price for a stay */
+    calculate(input: CalculateRateInput): Promise<RateCalculation>;
+    /** Push rates to portfolio properties */
+    pushToPortfolio(input: PushPortfolioRatesInput): Promise<PortfolioRatePushResult>;
+    /** Compare rates across portfolio properties */
+    comparePortfolioRates(input: ComparePortfolioRatesInput): Promise<PortfolioRateComparison>;
+}
+
 /**
  * Service for managing bookable spaces in the Atzentis Booking API.
  *
@@ -1980,6 +3464,154 @@ declare class SpacesService extends BaseService {
     linkPosTable(spaceId: string, input: LinkPosTableInput): Promise<Space>;
 }
 
+/** Department a staff member belongs to */
+type StaffDepartment = "front_desk" | "housekeeping" | "maintenance" | "food_beverage" | "management" | "spa" | "security" | "other";
+/** Role of a staff member */
+type StaffRole = "manager" | "supervisor" | "staff" | "intern" | "contractor";
+/** Employment status of a staff member */
+type StaffStatus = "active" | "inactive" | "on_leave";
+/** Type of shift */
+type ShiftType = "morning" | "afternoon" | "evening" | "night" | "custom";
+/** A staff member entity */
+interface Staff {
+    id: string;
+    propertyId: string;
+    firstName: string;
+    lastName: string;
+    email: string | null;
+    phone: string | null;
+    department: StaffDepartment;
+    role: StaffRole;
+    status: StaffStatus;
+    hireDate: string | null;
+    notes: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** A staff shift record */
+interface StaffShift {
+    id: string;
+    staffId: string;
+    propertyId: string;
+    shiftType: ShiftType;
+    startTime: string | null;
+    endTime: string | null;
+    date: string;
+    notes: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Input for creating a staff member */
+interface CreateStaffInput {
+    propertyId: string;
+    firstName: string;
+    lastName: string;
+    email?: string;
+    phone?: string;
+    department?: StaffDepartment;
+    role?: StaffRole;
+    status?: StaffStatus;
+    hireDate?: string;
+    notes?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Input for updating a staff member */
+interface UpdateStaffInput {
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    department?: StaffDepartment;
+    role?: StaffRole;
+    status?: StaffStatus;
+    hireDate?: string;
+    notes?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing staff members */
+interface ListStaffParams {
+    propertyId: string;
+    department?: StaffDepartment | StaffDepartment[];
+    role?: StaffRole | StaffRole[];
+    status?: StaffStatus;
+    search?: string;
+    limit?: number;
+    cursor?: string;
+}
+/** Paginated list of staff members */
+type PaginatedStaff = Paginated<Staff>;
+/** Input for creating a shift */
+interface CreateShiftInput {
+    date: string;
+    shiftType: ShiftType;
+    startTime?: string;
+    endTime?: string;
+    notes?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters for listing shifts */
+interface ListShiftsParams {
+    startDate?: string;
+    endDate?: string;
+    shiftType?: ShiftType | ShiftType[];
+    limit?: number;
+    cursor?: string;
+}
+
+/**
+ * Service for staff management in the Atzentis Booking API.
+ *
+ * Provides staff CRUD with department and role filtering,
+ * shift management with scheduling support, and multi-value
+ * filter serialization for department and role arrays.
+ *
+ * @example
+ * ```typescript
+ * const booking = new BookingClient({ apiKey: "atz_io_live_xxxxx" });
+ *
+ * // Create a staff member
+ * const member = await booking.staff.create({
+ *   propertyId: "prop_abc123",
+ *   firstName: "Maria",
+ *   lastName: "Papadopoulos",
+ *   department: "front_desk",
+ *   role: "supervisor",
+ * });
+ *
+ * // List housekeeping and maintenance staff
+ * const staff = await booking.staff.list({
+ *   propertyId: "prop_abc123",
+ *   department: ["housekeeping", "maintenance"],
+ *   status: "active",
+ * });
+ *
+ * // Schedule a morning shift
+ * await booking.staff.createShift(member.id, {
+ *   date: "2025-07-01",
+ *   shiftType: "morning",
+ * });
+ * ```
+ */
+declare class StaffService extends BaseService {
+    protected readonly basePath = "/operations/v1/staff";
+    /** Create a staff member */
+    create(input: CreateStaffInput): Promise<Staff>;
+    /** Get a staff member by ID */
+    get(staffId: string): Promise<Staff>;
+    /** List staff members with optional filters */
+    list(params: ListStaffParams): Promise<PaginatedStaff>;
+    /** Update a staff member */
+    update(staffId: string, input: UpdateStaffInput): Promise<Staff>;
+    /** Delete a staff member */
+    delete(staffId: string): Promise<void>;
+    /** Create a shift for a staff member */
+    createShift(staffId: string, input: CreateShiftInput): Promise<StaffShift>;
+    /** List shifts for a staff member */
+    listShifts(staffId: string, params?: ListShiftsParams): Promise<StaffShift[]>;
+}
+
 /**
  * Main SDK client for the Atzentis Booking API.
  *
@@ -1993,23 +3625,47 @@ declare class BookingClient {
     readonly httpClient: HttpClient;
     private _availability?;
     private _bookings?;
+    private _distribution?;
+    private _finance?;
+    private _groups?;
     private _guests?;
+    private _housekeeping?;
+    private _nightAudit?;
+    private _payments?;
     private _properties?;
+    private _ratePlans?;
     private _categories?;
     private _spaces?;
+    private _staff?;
     constructor(config: BookingClientConfig);
     /** Availability service — lazy-initialized on first access */
     get availability(): AvailabilityService;
     /** Bookings service — lazy-initialized on first access */
     get bookings(): BookingsService;
+    /** Distribution service — lazy-initialized on first access */
+    get distribution(): DistributionService;
+    /** Finance service — lazy-initialized on first access */
+    get finance(): FinanceService;
+    /** Groups service — lazy-initialized on first access */
+    get groups(): GroupsService;
     /** Guests service — lazy-initialized on first access */
     get guests(): GuestsService;
+    /** Housekeeping service — lazy-initialized on first access */
+    get housekeeping(): HousekeepingService;
+    /** Night audit service — lazy-initialized on first access */
+    get nightAudit(): NightAuditService;
+    /** Payments service — lazy-initialized on first access */
+    get payments(): PaymentsService;
     /** Properties service — lazy-initialized on first access */
     get properties(): PropertiesService;
+    /** Rate plans service — lazy-initialized on first access */
+    get ratePlans(): RatePlansService;
     /** Categories service — lazy-initialized on first access */
     get categories(): CategoriesService;
     /** Spaces service — lazy-initialized on first access */
     get spaces(): SpacesService;
+    /** Staff service — lazy-initialized on first access */
+    get staff(): StaffService;
     setApiKey(key: string): void;
     setTenantId(id: string): void;
 }
@@ -2092,4 +3748,4 @@ declare function firstPage<T>(fetcher: PageFetcher<T>, options?: PaginationOptio
 
 declare const VERSION = "0.1.0";
 
-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 CreateGuestInput, type CreatePropertyInput, type CreateSpaceInput, DEFAULT_MODULES, type DuplicateCandidate, ForbiddenError, type Guest, type GuestAddress, type GuestBookingSummary, type GuestDuplicateResult, type GuestFolioSummary, type GuestHistoryParams, type GuestMatch, type GuestOrderSummary, type GuestPreferences, type GuestSearchResult, type GuestSort, GuestsService, HttpClient, type HttpClientOptions, type HttpMethod, type HttpResponse, type LinkPosTableInput, type ListBookingsParams, type ListCategoriesParams, type ListGuestsParams, type ListPropertiesParams, type ListSpacesParams, type Logger, type MergeGuestsInput, type NoShowInput, NotFoundError, PROPERTY_MODULES, type PageFetcher, type Paginated, type PaginatedBookings, type PaginatedGuestBookings, type PaginatedGuestFolios, type PaginatedGuestOrders, type PaginatedGuests, 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, type SearchGuestsParams, ServerError, type ServiceSlotParams, type ServiceTimeSlot, type Space, type SpaceCategory, type SpaceStatus, type SpaceType, SpacesService, type TableSlotParams, type TimeSlot, TimeoutError, type UpdateBookingInput, type UpdateCategoryInput, type UpdateGuestInput, type UpdateGuestPreferences, type UpdatePropertyInput, type UpdateSpaceInput, VERSION, ValidationError, bookingClientConfigSchema, createErrorFromResponse, firstPage, paginate };
+export { type AccountingDailyReport, type AccountingReportParams, type AccountingRevenueReport, type AccountingVatReport, type AppliedRestriction, type AssignSpaceInput, AuthenticationError, type Authorization, type AuthorizationStatus, type AuthorizeInput, type AvailabilityCheckParams, type AvailabilityPricing, type AvailabilityRestrictions, type AvailabilityResult, type AvailabilitySearchParams, type AvailabilitySearchResult, type AvailabilitySearchResultEntry, AvailabilityService, type AvailableSpace, BOOKING_STATUSES, BOOKING_TYPES, type Block, type BlockDate, type Booking, BookingClient, type BookingClientConfig, BookingError, type BookingErrorOptions, type BookingGuest, type BookingPricing, type BookingSort, type BookingSpace, type BookingStatus, type BookingType, BookingsService, type BulkUpdateSpaceInput, type CalculateRateInput, type CalendarDay, type CalendarParams, type CancelBookingInput, type CaptureInput, type CardDetails, CategoriesService, type CategoryPickup, type Channel, type ChannelCredentials, type ChannelMapping, type ChannelSettings, type ChannelStatus, type ChannelType, type ChargeType, type CheckInInput, type CheckOutInput, type ComparePortfolioRatesInput, ConflictError, type Coordinates, type CreateBlockInput, type CreateBookingInput, type CreateCategoryInput, type CreateChannelInput, type CreateChargeInput, type CreateFolioInput, type CreateFolioPaymentInput, type CreateGroupFolioInput, type CreateGroupInput, type CreateGuestInput, type CreateHousekeepingTaskInput, type CreateInvoiceInput, type CreateMappingInput, type CreatePaymentAccountInput, type CreatePropertyInput, type CreateRatePeriodInput, type CreateRatePlanInput, type CreateShiftInput, type CreateSpaceInput, type CreateStaffInput, DEFAULT_MODULES, type DatePickup, DistributionService, type DuplicateCandidate, FinanceService, type Folio, type FolioCharge, type FolioPayment, type FolioPostCharge, type FolioPostInput, type FolioPostItem, type FolioPostResult, type FolioStatus, ForbiddenError, type GetBoardParams, type GetNightAuditHistoryParams, type Group, type GroupBlockSummary, type GroupFolioResult, type GroupStatus, type GroupType, GroupsService, type Guest, type GuestAddress, type GuestBookingSummary, type GuestDuplicateResult, type GuestFolioSummary, type GuestHistoryParams, type GuestMatch, type GuestOrderSummary, type GuestPreferences, type GuestSearchResult, type GuestSort, GuestsService, type HousekeepingBoard, type HousekeepingBoardEntry, type HousekeepingPriority, HousekeepingService, type HousekeepingStatus, type HousekeepingTask, type HousekeepingTaskStatus, type HousekeepingTaskType, HttpClient, type HttpClientOptions, type HttpMethod, type HttpResponse, type ICalExportResult, type ICalImportInput, type ICalImportResult, type Invoice, type InvoiceStatus, type IrisInitiateInput, type IrisTransfer, type IrisTransferStatus, type LinkPosTableInput, type ListBookingsParams, type ListCategoriesParams, type ListChannelsParams, type ListChargesParams, type ListFolioPaymentsParams, type ListFolioPostParams, type ListFoliosParams, type ListGroupsParams, type ListGuestsParams, type ListHousekeepingTasksParams, type ListMappingsParams, type ListPaymentAccountsParams, type ListPropertiesParams, type ListRatePeriodsParams, type ListRatePlansParams, type ListShiftsParams, type ListSpacesParams, type ListStaffParams, type ListTransactionsParams, type Logger, type MergeGuestsInput, type MoveChargesInput, type NightAuditDiscrepancy, type NightAuditError, type NightAuditOccupancy, type NightAuditPaymentMethod, type NightAuditPayments, type NightAuditReport, type NightAuditRevenue, type NightAuditRevenueBreakdown, type NightAuditRun, NightAuditService, type NightAuditStatus, type NightAuditSummary, type NightlyRate, type NoShowInput, NotFoundError, type OccupancyStatus, PROPERTY_MODULES, type PageFetcher, type Paginated, type PaginatedBookings, type PaginatedChannels, type PaginatedCharges, type PaginatedFolioPayments, type PaginatedFolioPostCharges, type PaginatedFolios, type PaginatedGroups, type PaginatedGuestBookings, type PaginatedGuestFolios, type PaginatedGuestOrders, type PaginatedGuests, type PaginatedHousekeepingTasks, type PaginatedMappings, type PaginatedNightAuditRuns, type PaginatedPaymentAccounts, type PaginatedRatePeriods, type PaginatedRatePlans, type PaginatedStaff, type PaginatedSyncLog, type PaginatedTransactions, type PaginationOptions, type Payment, type PaymentAccount, type PaymentAccountStatus, PaymentError, type PaymentProvider, type PaymentStatus, PaymentsService, type Pickup, type PortfolioPropertyRate, type PortfolioRateComparison, type PortfolioRatePushResult, type PortfolioTargetResult, type PriceRange, type PricingParams, type PricingResult, type ProcessPaymentInput, PropertiesService, type Property, type PropertyAddress, type PropertyModules, type PropertyStatus, type PropertyType, type PullSyncInput, type PushPortfolioRatesInput, type PushSyncInput, type RateCalculation, RateLimitError, type RateModifier, type RatePeriod, type RatePlan, type RatePlanStatus, RatePlansService, type RateRestriction, type Refund, type RefundInput, type RefundStatus, type ReleaseBlocksInput, type ReleaseResult, type RequestOptions, type ResolvedBookingClientConfig, type RetryConfig, type RetryOptions, type RunNightAuditInput, SPACE_STATUSES, SPACE_TYPES, type SearchGuestsParams, ServerError, type ServiceSlotParams, type ServiceTimeSlot, type ShiftType, type Space, type SpaceCategory, type SpaceStatus, type SpaceType, SpacesService, type Staff, type StaffDepartment, type StaffRole, StaffService, type StaffShift, type StaffStatus, type SyncError, type SyncLogParams, type SyncOperation, type SyncOperationStatus, type SyncOperationType, type SyncStats, type TableSlotParams, type TerminalAuthorizeInput, type TerminalTransaction, type TerminalTransactionStatus, type TimeSlot, TimeoutError, type Transaction, type TransactionType, type UpdateBookingInput, type UpdateCategoryInput, type UpdateChannelInput, type UpdateFolioInput, type UpdateGroupInput, type UpdateGuestInput, type UpdateGuestPreferences, type UpdateHousekeepingTaskInput, type UpdatePropertyInput, type UpdateRatePeriodInput, type UpdateRatePlanInput, type UpdateRateRestrictionInput, type UpdateSpaceInput, type UpdateSpaceStatusInput, type UpdateStaffInput, VERSION, ValidationError, type VatBreakdownEntry, bookingClientConfigSchema, createErrorFromResponse, firstPage, paginate };