ts-time-utils 4.0.1 → 4.4.0

package/dist/{recurrence.js → recurrence.cjs}

@@ -1,8 +1,16 @@
+"use strict";
 /**
  * @fileoverview Recurring events and pattern-based date generation utilities
  * Provides RRULE-inspired recurrence patterns for creating repeating events
  */
-import { addTime } from './calculate.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRecurrence = createRecurrence;
+exports.getNextOccurrence = getNextOccurrence;
+exports.getOccurrencesBetween = getOccurrencesBetween;
+exports.isRecurrenceDate = isRecurrenceDate;
+exports.isValidRecurrenceRule = isValidRecurrenceRule;
+exports.recurrenceToString = recurrenceToString;
+const calculate_js_1 = require("./calculate.cjs");
 /**
  * Creates a recurrence pattern generator
  * @param rule - The recurrence rule defining the pattern
@@ -34,7 +42,7 @@ import { addTime } from './calculate.js';
  * });
  * ```
  */
-export function createRecurrence(rule) {
+function createRecurrence(rule) {
     const startDate = new Date(rule.startDate);
     return {
         rule,
@@ -43,19 +51,17 @@ export function createRecurrence(rule) {
         isRecurrenceDate: (date) => isRecurrenceDate(date, rule),
         getAllOccurrences: (limit = 100) => {
             const occurrences = [];
-            let current = new Date(startDate);
-            let count = 0;
-            while (count < limit) {
+            let current = new Date(startDate.getTime() - 1);
+            while (occurrences.length < limit) {
                 if (rule.until && current > new Date(rule.until))
                     break;
-                if (rule.count && count >= rule.count)
+                if (rule.count && occurrences.length >= rule.count)
                     break;
                 const next = getNextOccurrence(rule, current);
                 if (!next)
                     break;
                 occurrences.push(next);
                 current = new Date(next.getTime() + 1);
-                count++;
             }
             return occurrences;
         }
@@ -79,7 +85,7 @@ export function createRecurrence(rule) {
  * // Returns Date('2024-01-07') - every other day
  * ```
  */
-export function getNextOccurrence(rule, afterDate) {
+function getNextOccurrence(rule, afterDate) {
     const after = afterDate ? new Date(afterDate) : new Date();
     const start = new Date(rule.startDate);
     // If afterDate is before start, check if start matches
@@ -94,7 +100,7 @@ export function getNextOccurrence(rule, afterDate) {
     }
     // Start searching from the day after 'after'
     // We want strictly greater than after, so start from the next potential occurrence
-    let candidate = addTime(after, 1, 'day');
+    let candidate = (0, calculate_js_1.addTime)(after, 1, 'day');
     // Preserve time from start date
     candidate.setHours(start.getHours(), start.getMinutes(), start.getSeconds(), start.getMilliseconds());
     const maxIterations = 1000; // Prevent infinite loops
@@ -137,7 +143,7 @@ export function getNextOccurrence(rule, afterDate) {
  * // Returns all Mondays and Fridays in January 2024
  * ```
  */
-export function getOccurrencesBetween(rule, start, end, limit = 1000) {
+function getOccurrencesBetween(rule, start, end, limit = 1000) {
     const startDate = new Date(start);
     const endDate = new Date(end);
     const occurrences = [];
@@ -179,7 +185,7 @@ export function getOccurrencesBetween(rule, start, end, limit = 1000) {
  * isRecurrenceDate(new Date('2024-01-09'), rule); // false (Tuesday)
  * ```
  */
-export function isRecurrenceDate(date, rule) {
+function isRecurrenceDate(date, rule) {
     const checkDate = new Date(date);
     const start = new Date(rule.startDate);
     // Must be on or after start date
@@ -210,7 +216,7 @@ export function isRecurrenceDate(date, rule) {
  * }); // false
  * ```
  */
-export function isValidRecurrenceRule(rule) {
+function isValidRecurrenceRule(rule) {
     if (!rule.frequency || !rule.startDate)
         return false;
     const validFrequencies = ['daily', 'weekly', 'monthly', 'yearly'];
@@ -264,7 +270,7 @@ export function isValidRecurrenceRule(rule) {
  * // "Every 2 weeks on Monday, Wednesday, Friday"
  * ```
  */
-export function recurrenceToString(rule) {
+function recurrenceToString(rule) {
     const interval = rule.interval || 1;
     let result = interval === 1 ? 'Every' : `Every ${interval}`;
     switch (rule.frequency) {
@@ -378,27 +384,27 @@ function getNextCandidate(date, rule) {
         case 'daily':
             // For daily recurrence, always increment by 1 day to check each day
             // matchesRecurrenceRule will filter based on interval
-            return addTime(date, 1, 'day');
+            return (0, calculate_js_1.addTime)(date, 1, 'day');
         case 'weekly':
             // If we have specific weekdays, try next day, otherwise skip full interval
             if (rule.byWeekday && rule.byWeekday.length > 0) {
-                return addTime(date, 1, 'day');
+                return (0, calculate_js_1.addTime)(date, 1, 'day');
             }
-            return addTime(date, interval * 7, 'day');
+            return (0, calculate_js_1.addTime)(date, interval * 7, 'day');
         case 'monthly':
             // If we have specific days of month, try next day, otherwise skip full interval
             if (rule.byMonthDay && rule.byMonthDay.length > 0) {
-                return addTime(date, 1, 'day');
+                return (0, calculate_js_1.addTime)(date, 1, 'day');
             }
-            return addTime(date, interval, 'month');
+            return (0, calculate_js_1.addTime)(date, interval, 'month');
         case 'yearly':
             // If we have specific months or days, try next day, otherwise skip full interval
             if ((rule.byMonth && rule.byMonth.length > 0) ||
                 (rule.byMonthDay && rule.byMonthDay.length > 0)) {
-                return addTime(date, 1, 'day');
+                return (0, calculate_js_1.addTime)(date, 1, 'day');
             }
-            return addTime(date, interval, 'year');
+            return (0, calculate_js_1.addTime)(date, interval, 'year');
         default:
-            return addTime(date, 1, 'day');
+            return (0, calculate_js_1.addTime)(date, 1, 'day');
     }
 }

package/dist/recurrence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recurrence.d.ts","sourceRoot":"","sources":["../src/recurrence.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAuB,MAAM,YAAY,CAAC;AAGjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc;;oCAKjB,SAAS;mCACV,SAAS,OAAO,SAAS,UAAU,MAAM;6BAE/C,SAAS;;EAqBrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAyC1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,SAAS,EACd,KAAK,SAAO,GACX,IAAI,EAAE,CA6BR;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAW/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAgC5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CA6C/D"}
+{"version":3,"file":"recurrence.d.ts","sourceRoot":"","sources":["../src/recurrence.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAuB,MAAM,YAAY,CAAC;AAGjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc;;oCAKjB,SAAS;mCACV,SAAS,OAAO,SAAS,UAAU,MAAM;6BAE/C,SAAS;;EAmBrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAyC1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,SAAS,EACd,KAAK,SAAO,GACX,IAAI,EAAE,CA6BR;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAW/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAgC5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CA6C/D"}

package/dist/scheduling.cjs

@@ -0,0 +1,344 @@
+"use strict";
+/**
+ * @fileoverview Scheduling and booking utilities
+ * Provides slot generation, availability checking, and conflict detection
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SCHEDULING_CONFIG = void 0;
+exports.generateSlots = generateSlots;
+exports.generateSlotsForRange = generateSlotsForRange;
+exports.getAvailableSlots = getAvailableSlots;
+exports.findNextAvailable = findNextAvailable;
+exports.isSlotAvailable = isSlotAvailable;
+exports.findConflicts = findConflicts;
+exports.hasConflict = hasConflict;
+exports.addBuffer = addBuffer;
+exports.removeBuffer = removeBuffer;
+exports.expandRecurringAvailability = expandRecurringAvailability;
+exports.mergeBookings = mergeBookings;
+exports.splitSlot = splitSlot;
+const dateRange_js_1 = require("./dateRange.cjs");
+const workingHours_js_1 = require("./workingHours.cjs");
+const recurrence_js_1 = require("./recurrence.cjs");
+/** Default scheduling configuration */
+exports.DEFAULT_SCHEDULING_CONFIG = {
+    workingHours: workingHours_js_1.DEFAULT_WORKING_HOURS,
+    bufferMinutes: 0,
+    slotDuration: 30,
+    holidays: []
+};
+/**
+ * Helper to convert DateInput to Date
+ */
+function toDate(input) {
+    if (input instanceof Date)
+        return new Date(input);
+    return new Date(input);
+}
+/**
+ * Check if a date is a holiday
+ */
+function isHoliday(date, holidays) {
+    const dateStr = date.toISOString().split('T')[0];
+    return holidays.some(h => h.toISOString().split('T')[0] === dateStr);
+}
+/**
+ * Generates time slots for a single day
+ * @param date - The date to generate slots for
+ * @param config - Scheduling configuration
+ * @returns Array of slots for the day
+ *
+ * @example
+ * ```ts
+ * const slots = generateSlots(new Date('2024-01-15'), { slotDuration: 30 });
+ * // Returns 30-minute slots during working hours
+ * ```
+ */
+function generateSlots(date, config = {}) {
+    const d = toDate(date);
+    const cfg = { ...exports.DEFAULT_SCHEDULING_CONFIG, ...config };
+    const workingHours = cfg.workingHours ?? workingHours_js_1.DEFAULT_WORKING_HOURS;
+    // Check if it's a working day and not a holiday
+    if (!(0, workingHours_js_1.isWorkingDay)(d, workingHours))
+        return [];
+    if (cfg.holidays && isHoliday(d, cfg.holidays))
+        return [];
+    const slots = [];
+    const slotDuration = cfg.slotDuration ?? 30;
+    const dayStart = (0, workingHours_js_1.getWorkDayStart)(d, workingHours);
+    const dayEnd = (0, workingHours_js_1.getWorkDayEnd)(d, workingHours);
+    let current = new Date(dayStart);
+    while (current < dayEnd) {
+        const slotEnd = new Date(current.getTime() + slotDuration * 60 * 1000);
+        // Don't create slots that extend past working hours
+        if (slotEnd <= dayEnd) {
+            // Check if slot is during working time (not during breaks)
+            const midpoint = new Date(current.getTime() + (slotDuration * 60 * 1000) / 2);
+            const available = (0, workingHours_js_1.isWorkingTime)(midpoint, workingHours);
+            slots.push({
+                start: new Date(current),
+                end: new Date(slotEnd),
+                available
+            });
+        }
+        current = slotEnd;
+    }
+    return slots;
+}
+/**
+ * Generates time slots for a date range
+ * @param range - The date range to generate slots for
+ * @param config - Scheduling configuration
+ * @returns Array of slots for all days in range
+ *
+ * @example
+ * ```ts
+ * const range = { start: new Date('2024-01-15'), end: new Date('2024-01-17') };
+ * const slots = generateSlotsForRange(range, { slotDuration: 60 });
+ * ```
+ */
+function generateSlotsForRange(range, config = {}) {
+    const slots = [];
+    const current = new Date(range.start);
+    current.setHours(0, 0, 0, 0);
+    const endDate = new Date(range.end);
+    endDate.setHours(23, 59, 59, 999);
+    while (current <= endDate) {
+        const daySlots = generateSlots(current, config);
+        slots.push(...daySlots);
+        current.setDate(current.getDate() + 1);
+    }
+    return slots;
+}
+/**
+ * Gets available slots for a day, excluding existing bookings
+ * @param date - The date to check
+ * @param bookings - Existing bookings
+ * @param config - Scheduling configuration
+ * @returns Array of available slots
+ *
+ * @example
+ * ```ts
+ * const bookings = [{ start: new Date('2024-01-15T10:00'), end: new Date('2024-01-15T11:00') }];
+ * const available = getAvailableSlots(new Date('2024-01-15'), bookings);
+ * ```
+ */
+function getAvailableSlots(date, bookings, config = {}) {
+    const cfg = { ...exports.DEFAULT_SCHEDULING_CONFIG, ...config };
+    const slots = generateSlots(date, cfg);
+    const bufferMs = (cfg.bufferMinutes ?? 0) * 60 * 1000;
+    return slots.map(slot => {
+        // Expand slot by buffer for conflict checking
+        const checkRange = {
+            start: new Date(slot.start.getTime() - bufferMs),
+            end: new Date(slot.end.getTime() + bufferMs)
+        };
+        const hasConflict = bookings.some(booking => (0, dateRange_js_1.dateRangeOverlap)(checkRange, booking));
+        return {
+            ...slot,
+            available: slot.available && !hasConflict
+        };
+    });
+}
+/**
+ * Finds the next available slot of specified duration
+ * @param after - Start searching after this date
+ * @param bookings - Existing bookings
+ * @param duration - Required slot duration in minutes
+ * @param config - Scheduling configuration
+ * @returns Next available slot or null if none found within 30 days
+ *
+ * @example
+ * ```ts
+ * const nextSlot = findNextAvailable(new Date(), bookings, 60);
+ * if (nextSlot) console.log(`Next 1-hour slot at ${nextSlot.start}`);
+ * ```
+ */
+function findNextAvailable(after, bookings, duration, config = {}) {
+    const startDate = toDate(after);
+    const cfg = { ...exports.DEFAULT_SCHEDULING_CONFIG, ...config, slotDuration: duration };
+    // Search up to 30 days ahead
+    for (let dayOffset = 0; dayOffset < 30; dayOffset++) {
+        const checkDate = new Date(startDate);
+        checkDate.setDate(checkDate.getDate() + dayOffset);
+        const availableSlots = getAvailableSlots(checkDate, bookings, cfg);
+        for (const slot of availableSlots) {
+            if (slot.available && slot.start >= startDate) {
+                return slot;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Checks if a slot is available (no conflicts with existing bookings)
+ * @param slot - The slot to check
+ * @param bookings - Existing bookings
+ * @returns True if slot is available
+ *
+ * @example
+ * ```ts
+ * const slot = { start: new Date('2024-01-15T14:00'), end: new Date('2024-01-15T15:00') };
+ * if (isSlotAvailable(slot, existingBookings)) {
+ *   // Book the slot
+ * }
+ * ```
+ */
+function isSlotAvailable(slot, bookings) {
+    return !bookings.some(booking => (0, dateRange_js_1.dateRangeOverlap)(slot, booking));
+}
+/**
+ * Finds bookings that conflict with a proposed time range
+ * @param bookings - Existing bookings
+ * @param proposed - Proposed time range
+ * @returns Array of conflicting bookings
+ *
+ * @example
+ * ```ts
+ * const conflicts = findConflicts(existingBookings, { start: propStart, end: propEnd });
+ * if (conflicts.length > 0) {
+ *   console.log('Conflicts with:', conflicts);
+ * }
+ * ```
+ */
+function findConflicts(bookings, proposed) {
+    return bookings.filter(booking => (0, dateRange_js_1.dateRangeOverlap)(booking, proposed));
+}
+/**
+ * Checks if a proposed time range has any conflicts
+ * @param bookings - Existing bookings
+ * @param proposed - Proposed time range
+ * @returns True if there are conflicts
+ *
+ * @example
+ * ```ts
+ * if (hasConflict(existingBookings, proposedMeeting)) {
+ *   console.log('Time slot not available');
+ * }
+ * ```
+ */
+function hasConflict(bookings, proposed) {
+    return bookings.some(booking => (0, dateRange_js_1.dateRangeOverlap)(booking, proposed));
+}
+/**
+ * Adds buffer time around a slot
+ * @param slot - The original slot
+ * @param bufferMinutes - Buffer time in minutes
+ * @returns New slot with buffer added
+ *
+ * @example
+ * ```ts
+ * const slot = { start: new Date('2024-01-15T10:00'), end: new Date('2024-01-15T11:00') };
+ * const buffered = addBuffer(slot, 15);
+ * // buffered.start = 09:45, buffered.end = 11:15
+ * ```
+ */
+function addBuffer(slot, bufferMinutes) {
+    const bufferMs = bufferMinutes * 60 * 1000;
+    return {
+        start: new Date(slot.start.getTime() - bufferMs),
+        end: new Date(slot.end.getTime() + bufferMs)
+    };
+}
+/**
+ * Removes buffer time from a slot
+ * @param slot - The buffered slot
+ * @param bufferMinutes - Buffer time in minutes to remove
+ * @returns New slot with buffer removed
+ *
+ * @example
+ * ```ts
+ * const bufferedSlot = { start: new Date('2024-01-15T09:45'), end: new Date('2024-01-15T11:15') };
+ * const original = removeBuffer(bufferedSlot, 15);
+ * // original.start = 10:00, original.end = 11:00
+ * ```
+ */
+function removeBuffer(slot, bufferMinutes) {
+    const bufferMs = bufferMinutes * 60 * 1000;
+    return {
+        start: new Date(slot.start.getTime() + bufferMs),
+        end: new Date(slot.end.getTime() - bufferMs)
+    };
+}
+/**
+ * Expands recurring availability pattern into concrete slots
+ * @param pattern - Recurrence pattern
+ * @param range - Date range to expand within
+ * @param config - Scheduling configuration
+ * @returns Array of slots from the recurring pattern
+ *
+ * @example
+ * ```ts
+ * const pattern = {
+ *   frequency: 'weekly',
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1, 3, 5], // Mon, Wed, Fri
+ *   until: new Date('2024-12-31')
+ * };
+ * const slots = expandRecurringAvailability(pattern, range);
+ * ```
+ */
+function expandRecurringAvailability(pattern, range, config = {}) {
+    const occurrences = (0, recurrence_js_1.getOccurrencesBetween)(pattern, range.start, range.end);
+    const slots = [];
+    for (const occurrence of occurrences) {
+        const daySlots = generateSlots(occurrence, config);
+        slots.push(...daySlots);
+    }
+    return slots;
+}
+/**
+ * Merges adjacent or overlapping bookings
+ * @param bookings - Array of bookings to merge
+ * @returns Array of merged bookings
+ *
+ * @example
+ * ```ts
+ * const bookings = [
+ *   { start: new Date('2024-01-15T09:00'), end: new Date('2024-01-15T10:00') },
+ *   { start: new Date('2024-01-15T10:00'), end: new Date('2024-01-15T11:00') }
+ * ];
+ * const merged = mergeBookings(bookings);
+ * // [{ start: 09:00, end: 11:00 }]
+ * ```
+ */
+function mergeBookings(bookings) {
+    if (bookings.length === 0)
+        return [];
+    const ranges = (0, dateRange_js_1.mergeDateRanges)(bookings);
+    return ranges.map(range => ({
+        start: range.start,
+        end: range.end
+    }));
+}
+/**
+ * Splits a slot at a specific time
+ * @param slot - The slot to split
+ * @param at - The time to split at
+ * @returns Tuple of two slots, or null if split point is outside slot
+ *
+ * @example
+ * ```ts
+ * const slot = { start: new Date('2024-01-15T09:00'), end: new Date('2024-01-15T11:00'), available: true };
+ * const [before, after] = splitSlot(slot, new Date('2024-01-15T10:00'));
+ * // before: 09:00-10:00, after: 10:00-11:00
+ * ```
+ */
+function splitSlot(slot, at) {
+    const splitTime = toDate(at);
+    if (splitTime <= slot.start || splitTime >= slot.end) {
+        return null;
+    }
+    return [
+        {
+            start: new Date(slot.start),
+            end: new Date(splitTime),
+            available: slot.available
+        },
+        {
+            start: new Date(splitTime),
+            end: new Date(slot.end),
+            available: slot.available
+        }
+    ];
+}

package/dist/scheduling.d.ts

@@ -0,0 +1,206 @@
+/**
+ * @fileoverview Scheduling and booking utilities
+ * Provides slot generation, availability checking, and conflict detection
+ */
+import type { DateRange, DateInput, WorkingHoursConfig, RecurrenceRule } from './types.js';
+/** Configuration for scheduling operations */
+export interface SchedulingConfig {
+    /** Working hours configuration */
+    workingHours?: WorkingHoursConfig;
+    /** Buffer time between appointments in minutes */
+    bufferMinutes?: number;
+    /** Default slot duration in minutes */
+    slotDuration?: number;
+    /** Holidays to exclude */
+    holidays?: Date[];
+}
+/** A time slot with availability status */
+export interface Slot {
+    start: Date;
+    end: Date;
+    available: boolean;
+}
+/** A booking with optional metadata */
+export interface Booking extends DateRange {
+    id?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Default scheduling configuration */
+export declare const DEFAULT_SCHEDULING_CONFIG: SchedulingConfig;
+/**
+ * Generates time slots for a single day
+ * @param date - The date to generate slots for
+ * @param config - Scheduling configuration
+ * @returns Array of slots for the day
+ *
+ * @example
+ * ```ts
+ * const slots = generateSlots(new Date('2024-01-15'), { slotDuration: 30 });
+ * // Returns 30-minute slots during working hours
+ * ```
+ */
+export declare function generateSlots(date: DateInput, config?: SchedulingConfig): Slot[];
+/**
+ * Generates time slots for a date range
+ * @param range - The date range to generate slots for
+ * @param config - Scheduling configuration
+ * @returns Array of slots for all days in range
+ *
+ * @example
+ * ```ts
+ * const range = { start: new Date('2024-01-15'), end: new Date('2024-01-17') };
+ * const slots = generateSlotsForRange(range, { slotDuration: 60 });
+ * ```
+ */
+export declare function generateSlotsForRange(range: DateRange, config?: SchedulingConfig): Slot[];
+/**
+ * Gets available slots for a day, excluding existing bookings
+ * @param date - The date to check
+ * @param bookings - Existing bookings
+ * @param config - Scheduling configuration
+ * @returns Array of available slots
+ *
+ * @example
+ * ```ts
+ * const bookings = [{ start: new Date('2024-01-15T10:00'), end: new Date('2024-01-15T11:00') }];
+ * const available = getAvailableSlots(new Date('2024-01-15'), bookings);
+ * ```
+ */
+export declare function getAvailableSlots(date: DateInput, bookings: Booking[], config?: SchedulingConfig): Slot[];
+/**
+ * Finds the next available slot of specified duration
+ * @param after - Start searching after this date
+ * @param bookings - Existing bookings
+ * @param duration - Required slot duration in minutes
+ * @param config - Scheduling configuration
+ * @returns Next available slot or null if none found within 30 days
+ *
+ * @example
+ * ```ts
+ * const nextSlot = findNextAvailable(new Date(), bookings, 60);
+ * if (nextSlot) console.log(`Next 1-hour slot at ${nextSlot.start}`);
+ * ```
+ */
+export declare function findNextAvailable(after: DateInput, bookings: Booking[], duration: number, config?: SchedulingConfig): Slot | null;
+/**
+ * Checks if a slot is available (no conflicts with existing bookings)
+ * @param slot - The slot to check
+ * @param bookings - Existing bookings
+ * @returns True if slot is available
+ *
+ * @example
+ * ```ts
+ * const slot = { start: new Date('2024-01-15T14:00'), end: new Date('2024-01-15T15:00') };
+ * if (isSlotAvailable(slot, existingBookings)) {
+ *   // Book the slot
+ * }
+ * ```
+ */
+export declare function isSlotAvailable(slot: DateRange, bookings: Booking[]): boolean;
+/**
+ * Finds bookings that conflict with a proposed time range
+ * @param bookings - Existing bookings
+ * @param proposed - Proposed time range
+ * @returns Array of conflicting bookings
+ *
+ * @example
+ * ```ts
+ * const conflicts = findConflicts(existingBookings, { start: propStart, end: propEnd });
+ * if (conflicts.length > 0) {
+ *   console.log('Conflicts with:', conflicts);
+ * }
+ * ```
+ */
+export declare function findConflicts(bookings: Booking[], proposed: DateRange): Booking[];
+/**
+ * Checks if a proposed time range has any conflicts
+ * @param bookings - Existing bookings
+ * @param proposed - Proposed time range
+ * @returns True if there are conflicts
+ *
+ * @example
+ * ```ts
+ * if (hasConflict(existingBookings, proposedMeeting)) {
+ *   console.log('Time slot not available');
+ * }
+ * ```
+ */
+export declare function hasConflict(bookings: Booking[], proposed: DateRange): boolean;
+/**
+ * Adds buffer time around a slot
+ * @param slot - The original slot
+ * @param bufferMinutes - Buffer time in minutes
+ * @returns New slot with buffer added
+ *
+ * @example
+ * ```ts
+ * const slot = { start: new Date('2024-01-15T10:00'), end: new Date('2024-01-15T11:00') };
+ * const buffered = addBuffer(slot, 15);
+ * // buffered.start = 09:45, buffered.end = 11:15
+ * ```
+ */
+export declare function addBuffer(slot: DateRange, bufferMinutes: number): DateRange;
+/**
+ * Removes buffer time from a slot
+ * @param slot - The buffered slot
+ * @param bufferMinutes - Buffer time in minutes to remove
+ * @returns New slot with buffer removed
+ *
+ * @example
+ * ```ts
+ * const bufferedSlot = { start: new Date('2024-01-15T09:45'), end: new Date('2024-01-15T11:15') };
+ * const original = removeBuffer(bufferedSlot, 15);
+ * // original.start = 10:00, original.end = 11:00
+ * ```
+ */
+export declare function removeBuffer(slot: DateRange, bufferMinutes: number): DateRange;
+/**
+ * Expands recurring availability pattern into concrete slots
+ * @param pattern - Recurrence pattern
+ * @param range - Date range to expand within
+ * @param config - Scheduling configuration
+ * @returns Array of slots from the recurring pattern
+ *
+ * @example
+ * ```ts
+ * const pattern = {
+ *   frequency: 'weekly',
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1, 3, 5], // Mon, Wed, Fri
+ *   until: new Date('2024-12-31')
+ * };
+ * const slots = expandRecurringAvailability(pattern, range);
+ * ```
+ */
+export declare function expandRecurringAvailability(pattern: RecurrenceRule, range: DateRange, config?: SchedulingConfig): Slot[];
+/**
+ * Merges adjacent or overlapping bookings
+ * @param bookings - Array of bookings to merge
+ * @returns Array of merged bookings
+ *
+ * @example
+ * ```ts
+ * const bookings = [
+ *   { start: new Date('2024-01-15T09:00'), end: new Date('2024-01-15T10:00') },
+ *   { start: new Date('2024-01-15T10:00'), end: new Date('2024-01-15T11:00') }
+ * ];
+ * const merged = mergeBookings(bookings);
+ * // [{ start: 09:00, end: 11:00 }]
+ * ```
+ */
+export declare function mergeBookings(bookings: Booking[]): Booking[];
+/**
+ * Splits a slot at a specific time
+ * @param slot - The slot to split
+ * @param at - The time to split at
+ * @returns Tuple of two slots, or null if split point is outside slot
+ *
+ * @example
+ * ```ts
+ * const slot = { start: new Date('2024-01-15T09:00'), end: new Date('2024-01-15T11:00'), available: true };
+ * const [before, after] = splitSlot(slot, new Date('2024-01-15T10:00'));
+ * // before: 09:00-10:00, after: 10:00-11:00
+ * ```
+ */
+export declare function splitSlot(slot: Slot, at: DateInput): [Slot, Slot] | null;
+//# sourceMappingURL=scheduling.d.ts.map