@explorins/pers-sdk 2.1.42 → 2.2.0-alpha.2

package/dist/chunks/{pers-sdk-DxYmXQcW.js → pers-sdk-C01Z2nmP.js}

@@ -1,4 +1,4 @@
-import { AccountOwnerType, MembershipRole, WebhookMethod, WebhookExecutionStatus } from '@explorins/pers-shared';
+import { AccountOwnerType, MembershipRole, WebhookMethod, WebhookExecutionStatus, validateAllFields, validateFieldValue } from '@explorins/pers-shared';
 import { i as isTokenExpired, d as decodeJwtPayload, e as getTokenTimeToLive, E as ErrorUtils, A as AuthenticationError, b as PersApiError } from './index--OssIds0.js';
 import { UserService, UserApi } from '../user.js';
 import { createUserStatusSDK } from '../user-status.js';
@@ -1585,7 +1585,7 @@ class DefaultAuthProvider {
 /** SDK package name */
 const SDK_NAME = "@explorins/pers-sdk";
 /** SDK version - injected from package.json at build time */
-const SDK_VERSION = "2.1.42";
+const SDK_VERSION = "2.2.0-alpha.2";
 /** Full SDK identifier for headers */
 const SDK_USER_AGENT = `${SDK_NAME}/${SDK_VERSION}`;
 
@@ -1921,6 +1921,24 @@ class PersApiClient {
         else if (this.mergedConfig.apiProjectKey) {
             headers['x-project-key'] = this.mergedConfig.apiProjectKey;
         }
+        // Add data source tracking headers
+        const dataSource = this.mergedConfig.dataSource;
+        if (dataSource) {
+            headers['x-source-channel'] = dataSource.channel;
+            if (dataSource.medium) {
+                headers['x-source-medium'] = dataSource.medium;
+            }
+            if (dataSource.campaign) {
+                headers['x-source-campaign'] = dataSource.campaign;
+            }
+            if (dataSource.source) {
+                headers['x-source'] = dataSource.source;
+            }
+            // Note: referrer is typically set by browser, but can be overridden
+            if (dataSource.referrer) {
+                headers['Referer'] = dataSource.referrer;
+            }
+        }
         return headers;
     }
     // ==========================================
@@ -10106,6 +10124,835 @@ class WalletEventsManager {
     }
 }
 
+/**
+ * Custom Field Definitions API
+ *
+ * Low-level API for custom field definition CRUD operations.
+ * Used internally by CustomFieldDefinitionManager.
+ *
+ * @internal
+ */
+class CustomFieldApi {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.basePath = '/custom-field-definitions';
+    }
+    /**
+     * List all custom field definitions
+     * Backend returns non-paginated array sorted by sortOrder
+     */
+    async getDefinitions(entityType) {
+        const params = new URLSearchParams();
+        if (entityType) {
+            params.append('entityType', entityType);
+        }
+        const query = params.toString();
+        const url = query ? `${this.basePath}?${query}` : this.basePath;
+        return this.apiClient.get(url);
+    }
+    /**
+     * Get a single custom field definition by ID
+     */
+    async getDefinition(id) {
+        return this.apiClient.get(`${this.basePath}/${id}`);
+    }
+    /**
+     * Create a new custom field definition
+     */
+    async createDefinition(data) {
+        return this.apiClient.post(this.basePath, data);
+    }
+    /**
+     * Update an existing custom field definition
+     */
+    async updateDefinition(id, data) {
+        return this.apiClient.put(`${this.basePath}/${id}`, data);
+    }
+    /**
+     * Delete a custom field definition
+     */
+    async deleteDefinition(id) {
+        return this.apiClient.delete(`${this.basePath}/${id}`);
+    }
+    /**
+     * Get usage count for a field definition
+     */
+    async getUsages(id) {
+        return this.apiClient.get(`${this.basePath}/${id}/usages`);
+    }
+    /**
+     * Resolve dynamic select options for a field
+     */
+    async resolveSelectOptions(id) {
+        return this.apiClient.get(`${this.basePath}/${id}/options`);
+    }
+}
+
+/**
+ * Custom Field Definition Manager - Manage tenant-specific custom fields
+ *
+ * Provides CRUD operations for custom field definitions that extend the built-in
+ * user profile fields. Custom fields are defined per-tenant and can be used for
+ * additional user data collection, redemption requirements, and form validation.
+ *
+ * @group Managers
+ * @category Custom Fields
+ *
+ * @example Basic Operations
+ * ```typescript
+ * // List all user custom fields
+ * const fields = await sdk.customFields.getDefinitions();
+ *
+ * // Create a new custom field
+ * const field = await sdk.customFields.createDefinition({
+ *   key: 'employee_id',
+ *   label: 'Employee ID',
+ *   fieldType: 'text',
+ *   validation: { required: true, pattern: '^E[0-9]{5}$' }
+ * });
+ *
+ * // Update a field
+ * await sdk.customFields.updateDefinition(field.id, {
+ *   label: 'Company Employee ID'
+ * });
+ *
+ * // Delete a field
+ * await sdk.customFields.deleteDefinition(field.id);
+ * ```
+ *
+ * @example Validation
+ * ```typescript
+ * // Validate user custom data against definitions
+ * const definitions = await sdk.customFields.getDefinitions();
+ * const errors = sdk.customFields.validateUserData(
+ *   { employee_id: 'INVALID' },
+ *   definitions
+ * );
+ * if (errors.length > 0) {
+ *   console.log('Validation errors:', errors);
+ * }
+ * ```
+ */
+class CustomFieldDefinitionManager {
+    constructor(apiClient, events) {
+        this.events = events;
+        this.api = new CustomFieldApi(apiClient);
+    }
+    /**
+     * List all custom field definitions for the tenant
+     *
+     * Retrieves all custom field definitions, optionally filtered by entity type.
+     * Results are sorted by sortOrder (ascending).
+     *
+     * @param options - Query options including entity type filter
+     * @returns Array of custom field definitions
+     *
+     * @example List All User Fields
+     * ```typescript
+     * const fields = await sdk.customFields.getDefinitions();
+     * console.log(`Found ${fields.length} custom fields`);
+     *
+     * fields.forEach(field => {
+     *   console.log(`${field.key}: ${field.label} (${field.fieldType})`);
+     * });
+     * ```
+     *
+     * @example Filter by Entity Type
+     * ```typescript
+     * // Get only business custom fields
+     * const businessFields = await sdk.customFields.getDefinitions({
+     *   entityType: 'business'
+     * });
+     * ```
+     */
+    async getDefinitions(options) {
+        return this.api.getDefinitions(options?.entityType);
+    }
+    /**
+     * Get a single custom field definition by ID
+     *
+     * @param id - The UUID of the custom field definition
+     * @returns The custom field definition
+     * @throws {PersApiError} When definition not found (404)
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const field = await sdk.customFields.getDefinition('uuid-here');
+     *   console.log('Field:', field.label);
+     * } catch (error) {
+     *   if (error.statusCode === 404) {
+     *     console.log('Field not found');
+     *   }
+     * }
+     * ```
+     */
+    async getDefinition(id) {
+        return this.api.getDefinition(id);
+    }
+    /**
+     * Create a new custom field definition
+     *
+     * Creates a new custom field for the tenant. The field key must be unique
+     * within the tenant and entity type combination.
+     *
+     * @param data - The field definition data
+     * @returns The created custom field definition
+     * @throws {PersApiError} When key already exists (409) or validation fails (400)
+     *
+     * @example Text Field with Pattern
+     * ```typescript
+     * const employeeIdField = await sdk.customFields.createDefinition({
+     *   key: 'employee_id',
+     *   label: 'Employee ID',
+     *   description: 'Your company employee ID (E + 5 digits)',
+     *   fieldType: 'text',
+     *   validation: {
+     *     required: true,
+     *     pattern: '^E[0-9]{5}$',
+     *     patternMessage: 'Must be E followed by 5 digits'
+     *   },
+     *   sortOrder: 1
+     * });
+     * ```
+     *
+     * @example Date Field with Comparison
+     * ```typescript
+     * const checkOutField = await sdk.customFields.createDefinition({
+     *   key: 'check_out',
+     *   label: 'Check-out Date',
+     *   fieldType: 'date',
+     *   validation: {
+     *     required: true,
+     *     comparisons: [
+     *       { field: 'check_in', operator: '>', message: 'Must be after check-in' }
+     *     ]
+     *   },
+     *   sortOrder: 2
+     * });
+     * ```
+     *
+     * @example Select Field with Static Options
+     * ```typescript
+     * const departmentField = await sdk.customFields.createDefinition({
+     *   key: 'department',
+     *   label: 'Department',
+     *   fieldType: 'select',
+     *   selectOptions: [
+     *     { value: 'engineering', label: 'Engineering' },
+     *     { value: 'sales', label: 'Sales' },
+     *     { value: 'hr', label: 'Human Resources' }
+     *   ],
+     *   validation: { required: true }
+     * });
+     * ```
+     *
+     * @example Select Field with Dynamic Options
+     * ```typescript
+     * const hotelField = await sdk.customFields.createDefinition({
+     *   key: 'preferred_hotel',
+     *   label: 'Preferred Hotel',
+     *   fieldType: 'select',
+     *   selectOptionsSource: {
+     *     entity: 'business',
+     *     valueField: 'id',
+     *     labelField: 'name',
+     *     filter: { tags: ['hotel'], isActive: true }
+     *   },
+     *   validation: { required: true }
+     * });
+     * ```
+     */
+    async createDefinition(data) {
+        const result = await this.api.createDefinition(data);
+        // Using 'user' domain until pers-shared adds 'customField' domain
+        this.events?.emitSuccess({
+            domain: 'user',
+            type: 'definition_created',
+            userMessage: `Custom field "${result.label}" created`,
+            details: { id: result.id, key: result.key }
+        });
+        return result;
+    }
+    /**
+     * Update an existing custom field definition
+     *
+     * Updates a custom field definition. Note that key and entityType cannot
+     * be changed after creation.
+     *
+     * @param id - The UUID of the custom field definition to update
+     * @param data - The fields to update (partial update supported)
+     * @returns The updated custom field definition
+     * @throws {PersApiError} When definition not found (404) or validation fails (400)
+     *
+     * @example Update Label and Validation
+     * ```typescript
+     * const updated = await sdk.customFields.updateDefinition('uuid-here', {
+     *   label: 'Employee ID (Required)',
+     *   validation: {
+     *     required: true,
+     *     minLength: 6,
+     *     maxLength: 6
+     *   }
+     * });
+     * ```
+     *
+     * @example Update Sort Order
+     * ```typescript
+     * await sdk.customFields.updateDefinition('uuid-here', {
+     *   sortOrder: 5
+     * });
+     * ```
+     */
+    async updateDefinition(id, data) {
+        const result = await this.api.updateDefinition(id, data);
+        // Using 'user' domain until pers-shared adds 'customField' domain
+        this.events?.emitSuccess({
+            domain: 'user',
+            type: 'definition_updated',
+            userMessage: `Custom field "${result.label}" updated`,
+            details: { id: result.id, key: result.key }
+        });
+        return result;
+    }
+    /**
+     * Delete a custom field definition (soft delete)
+     *
+     * Soft deletes a custom field definition. Existing user data in customData
+     * is preserved, but the field will no longer appear in forms or validation.
+     *
+     * ⚠️ Consider the impact on existing user data before deleting.
+     *
+     * @param id - The UUID of the custom field definition to delete
+     * @throws {PersApiError} When definition not found (404)
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await sdk.customFields.deleteDefinition('uuid-here');
+     *   console.log('Field deleted');
+     * } catch (error) {
+     *   console.log('Failed to delete:', error.message);
+     * }
+     * ```
+     */
+    async deleteDefinition(id) {
+        await this.api.deleteDefinition(id);
+        // Using 'user' domain until pers-shared adds 'customField' domain
+        this.events?.emitSuccess({
+            domain: 'user',
+            type: 'definition_deleted',
+            userMessage: 'Custom field deleted',
+            details: { id }
+        });
+    }
+    /**
+     * Resolve dynamic select options for a field
+     *
+     * For fields with selectOptionsSource (dynamic options from entities),
+     * this resolves the actual options by querying the source entity.
+     *
+     * @param id - The UUID of the custom field definition
+     * @returns Array of select options
+     *
+     * @example
+     * ```typescript
+     * const field = await sdk.customFields.getDefinition('hotel-field-id');
+     *
+     * if (field.selectOptionsSource) {
+     *   // Options come from entity - need to resolve
+     *   const options = await sdk.customFields.resolveSelectOptions(field.id);
+     *   console.log('Available hotels:', options);
+     * } else {
+     *   // Static options
+     *   console.log('Options:', field.selectOptions);
+     * }
+     * ```
+     */
+    async resolveSelectOptions(id) {
+        const response = await this.api.resolveSelectOptions(id);
+        return response.options;
+    }
+    /**
+     * Validate user custom data against field definitions
+     *
+     * Client-side validation using the same rules as the backend. Use this
+     * to validate form data before submission.
+     *
+     * @param data - User's custom data (key-value pairs)
+     * @param definitions - Custom field definitions to validate against
+     * @returns Array of validation errors (empty if valid)
+     *
+     * @example Form Validation
+     * ```typescript
+     * const definitions = await sdk.customFields.getDefinitions();
+     * const formData = {
+     *   employee_id: 'E123', // Missing a digit
+     *   department: 'engineering'
+     * };
+     *
+     * const errors = sdk.customFields.validateUserData(formData, definitions);
+     * if (errors.length > 0) {
+     *   errors.forEach(err => {
+     *     console.log(`${err.field}: ${err.message}`);
+     *   });
+     *   return; // Don't submit
+     * }
+     *
+     * // No errors, safe to submit
+     * await sdk.users.updateCurrentUser({ customData: formData });
+     * ```
+     */
+    validateUserData(data, definitions) {
+        // Convert CustomFieldDefinitionDTO to FieldDefinition for validation
+        const fieldDefinitions = definitions.map(def => ({
+            key: def.key,
+            fieldType: def.fieldType,
+            label: def.label,
+            validation: def.validation ?? undefined,
+        }));
+        return validateAllFields(data, fieldDefinitions);
+    }
+    /**
+     * Validate a single field value
+     *
+     * Validates a single value against a field's rules. Useful for
+     * real-time validation as the user types.
+     *
+     * @param value - The value to validate
+     * @param definition - The field definition
+     * @returns Validation error or null if valid
+     *
+     * @example Real-time Validation
+     * ```typescript
+     * const employeeIdField = definitions.find(d => d.key === 'employee_id');
+     *
+     * const handleBlur = (value: string) => {
+     *   const error = sdk.customFields.validateFieldValue(value, employeeIdField);
+     *   if (error) {
+     *     setFieldError('employee_id', error.message);
+     *   } else {
+     *     clearFieldError('employee_id');
+     *   }
+     * };
+     * ```
+     */
+    validateFieldValue(value, definition) {
+        const error = validateFieldValue(value, definition.validation ?? null, definition.fieldType);
+        if (error) {
+            // Add field key to error
+            return { ...error, field: definition.key };
+        }
+        return null;
+    }
+}
+
+/**
+ * Low-level API for booking operations
+ *
+ * Provides direct HTTP calls to the booking endpoints.
+ * For most use cases, prefer using BookingManager or BookingService.
+ *
+ * @internal
+ */
+class BookingApi {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.basePath = '/bookings';
+    }
+    /**
+     * List all bookings with optional filters
+     *
+     * @param options - Filter options (userId, businessId, status)
+     * @returns Promise resolving to array of bookings
+     */
+    async getAll(options) {
+        const params = new URLSearchParams();
+        if (options?.userId) {
+            params.append('userId', options.userId);
+        }
+        if (options?.businessId) {
+            params.append('businessId', options.businessId);
+        }
+        if (options?.status) {
+            params.append('status', options.status);
+        }
+        const queryString = params.toString();
+        const url = queryString ? `${this.basePath}?${queryString}` : this.basePath;
+        return this.apiClient.get(url);
+    }
+    /**
+     * Get a single booking by ID
+     *
+     * @param id - Booking UUID
+     * @returns Promise resolving to booking data
+     */
+    async getById(id) {
+        return this.apiClient.get(`${this.basePath}/${id}`);
+    }
+    /**
+     * Create a new booking
+     *
+     * @param data - Booking creation data
+     * @returns Promise resolving to created booking
+     */
+    async create(data) {
+        return this.apiClient.post(this.basePath, data);
+    }
+    /**
+     * Update an existing booking
+     *
+     * @param id - Booking UUID
+     * @param data - Booking update data
+     * @returns Promise resolving to updated booking
+     */
+    async update(id, data) {
+        return this.apiClient.put(`${this.basePath}/${id}`, data);
+    }
+    /**
+     * Delete a booking
+     *
+     * @param id - Booking UUID
+     * @returns Promise resolving to success status
+     */
+    async delete(id) {
+        return this.apiClient.delete(`${this.basePath}/${id}`);
+    }
+}
+
+/**
+ * Booking Service - Business logic layer for booking operations
+ *
+ * Provides booking management functionality with validation and
+ * business rule enforcement.
+ *
+ * @internal
+ */
+class BookingService {
+    constructor(bookingApi) {
+        this.bookingApi = bookingApi;
+    }
+    /**
+     * Get all bookings with optional filters
+     *
+     * @param options - Filter options
+     * @returns Promise resolving to array of bookings
+     */
+    async getAll(options) {
+        return this.bookingApi.getAll(options);
+    }
+    /**
+     * Get bookings for a specific user
+     *
+     * @param userId - User ID to filter by
+     * @param status - Optional status filter
+     * @returns Promise resolving to user's bookings
+     */
+    async getByUser(userId, status) {
+        return this.bookingApi.getAll({ userId, status });
+    }
+    /**
+     * Get bookings for a specific business
+     *
+     * @param businessId - Business ID to filter by
+     * @param status - Optional status filter
+     * @returns Promise resolving to business's bookings
+     */
+    async getByBusiness(businessId, status) {
+        return this.bookingApi.getAll({ businessId, status });
+    }
+    /**
+     * Get a single booking by ID
+     *
+     * @param id - Booking UUID
+     * @returns Promise resolving to booking data
+     */
+    async getById(id) {
+        return this.bookingApi.getById(id);
+    }
+    /**
+     * Create a new booking
+     *
+     * @param data - Booking creation data
+     * @returns Promise resolving to created booking
+     */
+    async create(data) {
+        // Validate check-out is after check-in
+        if (data.checkInDate && data.checkOutDate) {
+            const checkIn = new Date(data.checkInDate);
+            const checkOut = new Date(data.checkOutDate);
+            if (checkOut <= checkIn) {
+                throw new Error('Check-out date must be after check-in date');
+            }
+        }
+        return this.bookingApi.create(data);
+    }
+    /**
+     * Update an existing booking
+     *
+     * @param id - Booking UUID
+     * @param data - Booking update data
+     * @returns Promise resolving to updated booking
+     */
+    async update(id, data) {
+        // Validate dates if both provided
+        if (data.checkInDate && data.checkOutDate) {
+            const checkIn = new Date(data.checkInDate);
+            const checkOut = new Date(data.checkOutDate);
+            if (checkOut <= checkIn) {
+                throw new Error('Check-out date must be after check-in date');
+            }
+        }
+        return this.bookingApi.update(id, data);
+    }
+    /**
+     * Delete a booking
+     *
+     * @param id - Booking UUID
+     * @returns Promise resolving to success status
+     */
+    async delete(id) {
+        return this.bookingApi.delete(id);
+    }
+    /**
+     * Check if a user has an active or future booking
+     *
+     * Useful for eligibility checks on redemptions.
+     *
+     * @param userId - User ID to check
+     * @param options - Validation options (status filter, business filter)
+     * @returns Promise resolving to true if user has valid booking
+     */
+    async hasValidBooking(userId, options) {
+        const queryOptions = {
+            userId,
+            businessId: options?.businessId
+        };
+        // If a specific status is requested, use it
+        if (options?.status && options.status !== 'active_future') {
+            queryOptions.status = options.status === 'any' ? undefined : options.status;
+            const bookings = await this.bookingApi.getAll(queryOptions);
+            return bookings.length > 0;
+        }
+        // Default: check active+future (active_future or undefined)
+        const activeBookings = await this.bookingApi.getAll({ ...queryOptions, status: 'active' });
+        if (activeBookings.length > 0)
+            return true;
+        const futureBookings = await this.bookingApi.getAll({ ...queryOptions, status: 'future' });
+        return futureBookings.length > 0;
+    }
+}
+
+/**
+ * Booking Manager - High-level interface for booking operations
+ *
+ * Provides a simplified API for managing bookings (hotel stays, reservations, etc.)
+ * Used for tracking user stays and eligibility checks on redemptions.
+ *
+ * @group Managers
+ * @category Booking Management
+ *
+ * @example List Bookings
+ * ```typescript
+ * // Get all bookings
+ * const allBookings = await sdk.bookings.getAll();
+ *
+ * // Filter by user
+ * const userBookings = await sdk.bookings.getAll({ userId: 'user-123' });
+ *
+ * // Filter by status
+ * const activeBookings = await sdk.bookings.getAll({ status: 'active' });
+ * ```
+ *
+ * @example Create Booking
+ * ```typescript
+ * const booking = await sdk.bookings.create({
+ *   userId: 'user-123',
+ *   locationName: 'Grand Hotel',
+ *   checkInDate: '2026-06-01',
+ *   checkOutDate: '2026-06-05',
+ *   guests: 2
+ * });
+ * ```
+ *
+ * @example Check Eligibility
+ * ```typescript
+ * // Check if user has valid (active or future) booking
+ * const hasBooking = await sdk.bookings.hasValidBooking('user-123');
+ * if (hasBooking) {
+ *   // User is eligible for booking-required redemption
+ * }
+ * ```
+ */
+class BookingManager {
+    constructor(apiClient, events) {
+        this.apiClient = apiClient;
+        this.events = events;
+        const bookingApi = new BookingApi(apiClient);
+        this.bookingService = new BookingService(bookingApi);
+    }
+    /**
+     * Get all bookings with optional filters
+     *
+     * @param options - Filter options (userId, businessId, status)
+     * @returns Promise resolving to array of bookings
+     *
+     * @example Basic Usage
+     * ```typescript
+     * // All bookings
+     * const bookings = await sdk.bookings.getAll();
+     *
+     * // Filter by user
+     * const userBookings = await sdk.bookings.getAll({ userId: 'user-123' });
+     *
+     * // Filter by status
+     * const activeBookings = await sdk.bookings.getAll({ status: 'active' });
+     * const futureBookings = await sdk.bookings.getAll({ status: 'future' });
+     * const pastBookings = await sdk.bookings.getAll({ status: 'past' });
+     * ```
+     */
+    async getAll(options) {
+        return this.bookingService.getAll(options);
+    }
+    /**
+     * Get bookings for a specific user
+     *
+     * Convenience method for filtering bookings by user ID.
+     *
+     * @param userId - User ID to filter by
+     * @param status - Optional status filter
+     * @returns Promise resolving to user's bookings
+     */
+    async getByUser(userId, status) {
+        return this.bookingService.getByUser(userId, status);
+    }
+    /**
+     * Get bookings for a specific business
+     *
+     * Convenience method for filtering bookings by business ID.
+     *
+     * @param businessId - Business ID to filter by
+     * @param status - Optional status filter
+     * @returns Promise resolving to business's bookings
+     */
+    async getByBusiness(businessId, status) {
+        return this.bookingService.getByBusiness(businessId, status);
+    }
+    /**
+     * Get a single booking by ID
+     *
+     * @param id - Booking UUID
+     * @returns Promise resolving to booking data
+     * @throws {PersApiError} When booking not found
+     */
+    async getById(id) {
+        return this.bookingService.getById(id);
+    }
+    /**
+     * Create a new booking
+     *
+     * Creates a booking for a user at a specific location. Used for tracking
+     * hotel stays, reservations, etc. for eligibility checks.
+     *
+     * @param data - Booking creation data
+     * @returns Promise resolving to created booking
+     * @throws {Error} When check-out date is not after check-in date
+     *
+     * @example Create Hotel Booking
+     * ```typescript
+     * const booking = await sdk.bookings.create({
+     *   userId: 'user-123',
+     *   locationName: 'Grand Hotel',
+     *   locationType: 'hotel',
+     *   checkInDate: '2026-06-01',
+     *   checkOutDate: '2026-06-05',
+     *   confirmationNumber: 'CONF123',
+     *   guests: 2,
+     *   notes: 'Ocean view room'
+     * });
+     * ```
+     */
+    async create(data) {
+        const result = await this.bookingService.create(data);
+        // TODO: Add event emission when 'booking' domain is added to pers-shared
+        // this.events?.emitSuccess({ domain: 'booking', type: 'booking_created', ... });
+        return result;
+    }
+    /**
+     * Update an existing booking
+     *
+     * @param id - Booking UUID
+     * @param data - Booking update data (partial update supported)
+     * @returns Promise resolving to updated booking
+     * @throws {PersApiError} When booking not found
+     * @throws {Error} When check-out date is not after check-in date
+     *
+     * @example Update Booking Dates
+     * ```typescript
+     * const updated = await sdk.bookings.update('booking-123', {
+     *   checkInDate: '2026-06-02',
+     *   checkOutDate: '2026-06-07'
+     * });
+     * ```
+     */
+    async update(id, data) {
+        const result = await this.bookingService.update(id, data);
+        // TODO: Add event emission when 'booking' domain is added to pers-shared
+        // this.events?.emitSuccess({ domain: 'booking', type: 'booking_updated', ... });
+        return result;
+    }
+    /**
+     * Delete a booking
+     *
+     * @param id - Booking UUID
+     * @returns Promise resolving to success status
+     * @throws {PersApiError} When booking not found
+     */
+    async delete(id) {
+        const result = await this.bookingService.delete(id);
+        // TODO: Add event emission when 'booking' domain is added to pers-shared
+        // this.events?.emitSuccess({ domain: 'booking', type: 'booking_deleted', ... });
+        return result;
+    }
+    /**
+     * Check if a user has a valid (active or future) booking
+     *
+     * Useful for eligibility checks on redemptions that require a valid booking.
+     *
+     * @param userId - User ID to check
+     * @param options - Validation options (status filter, business filter)
+     * @returns Promise resolving to true if user has valid booking
+     *
+     * @example Eligibility Check
+     * ```typescript
+     * const hasBooking = await sdk.bookings.hasValidBooking('user-123');
+     *
+     * if (!hasBooking) {
+     *   console.log('User must have an active or upcoming booking');
+     * }
+     *
+     * // Check for active booking only
+     * const hasActive = await sdk.bookings.hasValidBooking('user-123', { status: 'active' });
+     *
+     * // Check for booking at specific business
+     * const hasHotelBooking = await sdk.bookings.hasValidBooking('user-123', {
+     *   businessId: 'hotel-123'
+     * });
+     * ```
+     */
+    async hasValidBooking(userId, options) {
+        return this.bookingService.hasValidBooking(userId, options);
+    }
+    /**
+     * Get the booking service for advanced operations
+     *
+     * @returns BookingService instance with full API access
+     */
+    getBookingService() {
+        return this.bookingService;
+    }
+}
+
 /**
  * @fileoverview PERS SDK - Platform-agnostic TypeScript SDK with High-Level Managers
  *
@@ -10794,6 +11641,78 @@ class PersSDK {
         }
         return this._webhooks;
     }
+    /**
+     * Custom Field Definition Manager - Manage tenant-specific custom fields
+     *
+     * Provides CRUD operations for custom field definitions that extend the built-in
+     * user profile fields. Custom fields are tenant-specific and support validation.
+     *
+     * @returns CustomFieldDefinitionManager instance
+     *
+     * @example Basic Operations
+     * ```typescript
+     * // List all custom fields
+     * const fields = await sdk.customFields.getDefinitions();
+     *
+     * // Create a new field
+     * const field = await sdk.customFields.createDefinition({
+     *   key: 'employee_id',
+     *   label: 'Employee ID',
+     *   fieldType: 'text',
+     *   validation: { required: true }
+     * });
+     *
+     * // Validate user data
+     * const errors = sdk.customFields.validateUserData(formData, fields.data);
+     * ```
+     */
+    get customFields() {
+        if (!this._customFields) {
+            this._customFields = new CustomFieldDefinitionManager(this.apiClient, this._events);
+        }
+        return this._customFields;
+    }
+    /**
+     * Booking manager - High-level booking operations
+     *
+     * Provides methods for managing user bookings (hotel stays, reservations, etc.)
+     * Used for eligibility checks on redemptions that require valid bookings.
+     *
+     * @returns BookingManager instance
+     *
+     * @example List User Bookings
+     * ```typescript
+     * // Get all bookings for a user
+     * const bookings = await sdk.bookings.getByUser('user-123');
+     *
+     * // Filter by status
+     * const activeBookings = await sdk.bookings.getAll({ status: 'active' });
+     * ```
+     *
+     * @example Create Booking
+     * ```typescript
+     * const booking = await sdk.bookings.create({
+     *   userId: 'user-123',
+     *   locationName: 'Grand Hotel',
+     *   checkInDate: '2026-06-01',
+     *   checkOutDate: '2026-06-05'
+     * });
+     * ```
+     *
+     * @example Eligibility Check
+     * ```typescript
+     * const hasBooking = await sdk.bookings.hasValidBooking('user-123');
+     * if (hasBooking) {
+     *   // User is eligible for booking-required redemption
+     * }
+     * ```
+     */
+    get bookings() {
+        if (!this._bookings) {
+            this._bookings = new BookingManager(this.apiClient, this._events);
+        }
+        return this._bookings;
+    }
     /**
      * Wallet Events Manager - Real-time blockchain events for user's wallets
      *
@@ -10900,5 +11819,5 @@ function createPersSDK(httpClient, config) {
     return new PersSDK(httpClient, config);
 }
 
-export { AuthTokenManager as A, BusinessManager as B, CampaignManager as C, DefaultAuthProvider as D, WalletEventsManager as E, FATAL_AUTH_CODES as F, AuthStatus as G, FileApi as H, IndexedDBTokenStorage as I, FileService as J, ApiKeyApi as K, LocalStorageTokenStorage as L, MemoryTokenStorage as M, WebhookApi as N, WebhookService as O, PersSDK as P, PersEventsClient as Q, RedemptionManager as R, SDK_NAME as S, TokenManager as T, UserManager as U, createPersEventsClient as V, WebDPoPCryptoProvider as W, AUTH_STORAGE_KEYS as a, DPOP_STORAGE_KEYS as b, SDK_VERSION as c, SDK_USER_AGENT as d, createPersSDK as e, PersApiClient as f, DEFAULT_PERS_CONFIG as g, buildApiRoot as h, buildWalletEventsWsUrl as i, StaticJwtAuthProvider as j, AuthApi as k, isFatalAuthErrorInMessage as l, mergeWithDefaults as m, AuthService as n, DPoPManager as o, PersEventEmitter as p, AuthManager as q, UserStatusManager as r, TransactionManager as s, PurchaseManager as t, FileManager as u, ApiKeyManager as v, AnalyticsManager as w, DonationManager as x, TriggerSourceManager as y, WebhookManager as z };
-//# sourceMappingURL=pers-sdk-DxYmXQcW.js.map
+export { AuthTokenManager as A, BusinessManager as B, CampaignManager as C, DefaultAuthProvider as D, WalletEventsManager as E, FATAL_AUTH_CODES as F, CustomFieldDefinitionManager as G, BookingManager as H, IndexedDBTokenStorage as I, AuthStatus as J, FileApi as K, LocalStorageTokenStorage as L, MemoryTokenStorage as M, FileService as N, ApiKeyApi as O, PersSDK as P, WebhookApi as Q, RedemptionManager as R, SDK_NAME as S, TokenManager as T, UserManager as U, WebhookService as V, WebDPoPCryptoProvider as W, BookingApi as X, BookingService as Y, PersEventsClient as Z, createPersEventsClient as _, AUTH_STORAGE_KEYS as a, DPOP_STORAGE_KEYS as b, SDK_VERSION as c, SDK_USER_AGENT as d, createPersSDK as e, PersApiClient as f, DEFAULT_PERS_CONFIG as g, buildApiRoot as h, buildWalletEventsWsUrl as i, StaticJwtAuthProvider as j, AuthApi as k, isFatalAuthErrorInMessage as l, mergeWithDefaults as m, AuthService as n, DPoPManager as o, PersEventEmitter as p, AuthManager as q, UserStatusManager as r, TransactionManager as s, PurchaseManager as t, FileManager as u, ApiKeyManager as v, AnalyticsManager as w, DonationManager as x, TriggerSourceManager as y, WebhookManager as z };
+//# sourceMappingURL=pers-sdk-C01Z2nmP.js.map