slotlock 0.5.2 → 0.5.3

package/booking-rules.d.ts

@@ -14,6 +14,18 @@ export interface SlotlockBookingRules {
      * (15: on the quarter hour): 1-1,440.
      */
     slotStepMinutes?: number;
+    /**
+     * Where the steps fall: this many minutes past each step from local midnight (with a 30-minute
+     * step, 15 starts bookings on :15 and :45): 0 to one less than the step. Without a step it is
+     * kept and does nothing.
+     */
+    stepOffsetMinutes?: number;
+    /**
+     * Minutes kept free before each booking made under the rule (preparation, travel), as its
+     * leading buffer: the database refuses a booking whose time, or trailing buffer, reaches into
+     * it. 0-1,440. A booking made before the rule, or imported, keeps none.
+     */
+    bufferBeforeMinutes?: number;
     /**
      * Minutes kept free after each booking made under the rule (cleaning, handover, travel), as its
      * trailing buffer, so the database refuses a booking that would start inside it: 0-1,440. A
@@ -42,19 +54,41 @@ export declare const SLOTLOCK_BOOKING_RULE_LIMITS: Readonly<{
     readonly minNoticeMinutes: readonly [0, 525600];
     readonly maxAdvanceDays: readonly [1, 3660];
     readonly slotStepMinutes: readonly [1, number];
+    readonly stepOffsetMinutes: readonly [0, number];
+    readonly bufferBeforeMinutes: readonly [0, number];
     readonly turnaroundMinutes: readonly [0, number];
     readonly checkInMinutes: readonly [1, number];
 }>;
 /** Booking rules from untrusted input, or a TypeError naming the field that is wrong. */
 export declare function parseBookingRules(value: unknown): SlotlockBookingRules;
+/**
+ * The rules that apply to a resource, merged from its own and its pool's and tenant's defaults
+ * (each validated when it was set), read leniently: each field is kept when it is valid on its own
+ * and dropped (named in `dropped`) when not. No cross-field check: a merge may join a pool's offset
+ * to a resource's own shorter step, and the offset then applies modulo the step. A merge never
+ * reads as refusing every booking.
+ */
+export declare function parseEffectiveBookingRules(value: unknown): {
+    rules: SlotlockBookingRules;
+    dropped: string[];
+};
+/**
+ * Default booking rules for a tenant or a pool from untrusted input: booking rules without
+ * `checkInMinutes`, which only a resource's own rules set (it releases the bookings made after it
+ * was set, and that moment is the resource's).
+ */
+export declare function parseBookingRuleDefaults(value: unknown): SlotlockBookingRules;
 /** The trailing buffer a booking made under the rules keeps: the larger of its own and the rule's. */
 export declare function bookingBufferAfterMs(rules: SlotlockBookingRules | undefined, ownMs?: number): number;
+/** The leading buffer a booking made under the rules keeps. */
+export declare function bookingBufferBeforeMs(rules: SlotlockBookingRules | undefined): number;
 /**
- * The first instant at or after `from` that starts on a step in `timezone`. A step that does not
+ * The first instant at or after `from` that starts on a step in `timezone`, `offsetMinutes` past
+ * each multiple of the step from local midnight (0 to the step less one). A step that does not
  * divide the day starts again at local midnight. Across a clock change it moves forward until the
  * local time is on a step.
  */
-export declare function nextStepStart(from: Date, stepMinutes: number, timezone: string): Date;
+export declare function nextStepStart(from: Date, stepMinutes: number, timezone: string, offsetMinutes?: number): Date;
 /**
  * The rule a booking of `interval` made at `now` breaks, or null. `hours` are the resource's
  * bookable hours (its own, or the default), read only when the rules enforce them.
@@ -66,10 +100,21 @@ export declare function bookingRuleBroken(params: {
     interval: Interval;
     now: Date;
 }): SlotlockBookingRule | null;
+/** How a search honours the rules (`bookingSearch`). */
+export interface SlotlockBookingSearch {
+    /** The part of the asked window a booking made now may start in. */
+    window: Interval;
+    /** The trailing buffer each slot keeps. */
+    bufferAfterMs: number;
+    /** The leading buffer each slot keeps. */
+    bufferBeforeMs: number;
+    /** The first allowed start at or after a candidate. */
+    align?: (start: Date) => Date;
+}
 /**
  * How a search honours the rules: the part of `window` a booking made at `now` may start in, the
- * trailing buffer each slot keeps, and how a candidate start moves to a step. `null` when no start
- * in the window is allowed.
+ * buffers each slot keeps, and how a candidate start moves to a step. `null` when no start in the
+ * window is allowed.
  */
 export declare function bookingSearch(params: {
     rules: SlotlockBookingRules | undefined;
@@ -77,8 +122,15 @@ export declare function bookingSearch(params: {
     window: Interval;
     now: Date;
     bufferAfterMs?: number;
-}): {
-    window: Interval;
-    bufferAfterMs: number;
-    align?: (start: Date) => Date;
-} | null;
+}): SlotlockBookingSearch | null;
+/**
+ * The time a search must read as free or busy: its window, widened by the buffers a slot in it
+ * keeps (before its first start and after its last end).
+ */
+export declare function bookingSearchReach(search: SlotlockBookingSearch): Interval;
+/**
+ * Busy time as the slot times it rules out. A slot [s, s + d) keeping buffers occupies
+ * [s - before, s + d + after), so it meets busy [b, e) exactly when [s, s + d) meets
+ * [b - after, e + before): the database refuses the same booking.
+ */
+export declare function bookingSearchBlocked(busy: readonly Interval[], search: SlotlockBookingSearch): Interval[];

package/booking-rules.js

@@ -7,6 +7,8 @@ export const SLOTLOCK_BOOKING_RULE_LIMITS = Object.freeze({
     minNoticeMinutes: [0, 525_600],
     maxAdvanceDays: [1, 3_660],
     slotStepMinutes: [1, DAY_MINUTES],
+    stepOffsetMinutes: [0, DAY_MINUTES - 1],
+    bufferBeforeMinutes: [0, DAY_MINUTES],
     turnaroundMinutes: [0, DAY_MINUTES],
     checkInMinutes: [1, DAY_MINUTES],
 });
@@ -44,33 +46,96 @@ export function parseBookingRules(value) {
         }
         rules.requireCertain = input.requireCertain;
     }
+    if (rules.stepOffsetMinutes !== undefined &&
+        rules.slotStepMinutes !== undefined &&
+        rules.stepOffsetMinutes >= rules.slotStepMinutes) {
+        throw new TypeError('Slotlock booking rule stepOffsetMinutes must be less than slotStepMinutes');
+    }
+    return rules;
+}
+/**
+ * The rules that apply to a resource, merged from its own and its pool's and tenant's defaults
+ * (each validated when it was set), read leniently: each field is kept when it is valid on its own
+ * and dropped (named in `dropped`) when not. No cross-field check: a merge may join a pool's offset
+ * to a resource's own shorter step, and the offset then applies modulo the step. A merge never
+ * reads as refusing every booking.
+ */
+export function parseEffectiveBookingRules(value) {
+    const rules = {};
+    const dropped = [];
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return { rules, dropped: ['(not an object)'] };
+    }
+    for (const [key, field] of Object.entries(value)) {
+        if (key === 'enforceHours' || key === 'requireCertain') {
+            if (typeof field === 'boolean')
+                rules[key] = field;
+            else
+                dropped.push(key);
+            continue;
+        }
+        const limits = LIMITS[key];
+        if (limits === undefined ||
+            typeof field !== 'number' ||
+            !Number.isSafeInteger(field) ||
+            field < limits[0] ||
+            field > limits[1]) {
+            dropped.push(key);
+            continue;
+        }
+        rules[key] = field;
+    }
+    return { rules, dropped };
+}
+/**
+ * Default booking rules for a tenant or a pool from untrusted input: booking rules without
+ * `checkInMinutes`, which only a resource's own rules set (it releases the bookings made after it
+ * was set, and that moment is the resource's).
+ */
+export function parseBookingRuleDefaults(value) {
+    const rules = parseBookingRules(value);
+    if (rules.checkInMinutes !== undefined) {
+        throw new TypeError('Slotlock default booking rules have no checkInMinutes: set it on the resource');
+    }
     return rules;
 }
 /** The trailing buffer a booking made under the rules keeps: the larger of its own and the rule's. */
 export function bookingBufferAfterMs(rules, ownMs = 0) {
     return Math.max(ownMs, (rules?.turnaroundMinutes ?? 0) * MINUTE_MS);
 }
+/** The leading buffer a booking made under the rules keeps. */
+export function bookingBufferBeforeMs(rules) {
+    return (rules?.bufferBeforeMinutes ?? 0) * MINUTE_MS;
+}
+/** The step's offset as it applies: none without a step, and always less than the step. */
+function stepOffset(rules) {
+    const step = rules?.slotStepMinutes;
+    return step === undefined ? 0 : (rules?.stepOffsetMinutes ?? 0) % step;
+}
 /** Minutes past local midnight in `timezone`, with the fraction. */
 function localMinutes(instant, timezone) {
     const local = instant.getTime() + zonedOffsetMinutes(instant, timezone) * MINUTE_MS;
     return (((local / MINUTE_MS) % DAY_MINUTES) + DAY_MINUTES) % DAY_MINUTES;
 }
-function onStep(instant, stepMinutes, timezone) {
+/** Whether `instant` falls on a step: `offset` minutes past a multiple of the step, local time. */
+function onStep(instant, stepMinutes, timezone, offset = 0) {
     const minutes = localMinutes(instant, timezone);
-    return Number.isInteger(minutes) && minutes % stepMinutes === 0;
+    return Number.isInteger(minutes) && minutes >= offset && (minutes - offset) % stepMinutes === 0;
 }
 /**
- * The first instant at or after `from` that starts on a step in `timezone`. A step that does not
+ * The first instant at or after `from` that starts on a step in `timezone`, `offsetMinutes` past
+ * each multiple of the step from local midnight (0 to the step less one). A step that does not
  * divide the day starts again at local midnight. Across a clock change it moves forward until the
  * local time is on a step.
  */
-export function nextStepStart(from, stepMinutes, timezone) {
+export function nextStepStart(from, stepMinutes, timezone, offsetMinutes = 0) {
+    const offset = offsetMinutes % stepMinutes;
     let candidate = from;
-    for (let attempt = 0; attempt < 4; attempt++) {
-        if (onStep(candidate, stepMinutes, timezone))
+    for (let attempt = 0; attempt < 6; attempt++) {
+        if (onStep(candidate, stepMinutes, timezone, offset))
             return candidate;
         const minutes = localMinutes(candidate, timezone);
-        const next = Math.min(Math.ceil(minutes / stepMinutes + 1e-9) * stepMinutes, DAY_MINUTES);
+        const next = Math.min(offset + Math.max(0, Math.ceil((minutes - offset) / stepMinutes + 1e-9)) * stepMinutes, DAY_MINUTES);
         const ahead = Math.max(next - minutes, 1 / 60_000);
         candidate = new Date(Math.ceil(candidate.getTime() + ahead * MINUTE_MS));
     }
@@ -92,7 +157,8 @@ export function bookingRuleBroken(params) {
         start > now.getTime() + rules.maxAdvanceDays * DAY_MINUTES * MINUTE_MS) {
         return 'max_advance';
     }
-    if (rules.slotStepMinutes !== undefined && !onStep(interval.start, rules.slotStepMinutes, params.timezone)) {
+    if (rules.slotStepMinutes !== undefined &&
+        !onStep(interval.start, rules.slotStepMinutes, params.timezone, stepOffset(rules))) {
         return 'slot_step';
     }
     if (rules.enforceHours === true) {
@@ -112,30 +178,33 @@ export function bookingRuleBroken(params) {
 }
 /**
  * How a search honours the rules: the part of `window` a booking made at `now` may start in, the
- * trailing buffer each slot keeps, and how a candidate start moves to a step. `null` when no start
- * in the window is allowed.
+ * buffers each slot keeps, and how a candidate start moves to a step. `null` when no start in the
+ * window is allowed.
  */
 export function bookingSearch(params) {
     const { rules, window, now } = params;
     let start = window.start.getTime();
-    let end = window.end.getTime();
+    const end = window.end.getTime();
     if (rules?.minNoticeMinutes !== undefined) {
         start = Math.max(start, now.getTime() + rules.minNoticeMinutes * MINUTE_MS);
     }
     const bufferAfterMs = bookingBufferAfterMs(rules, params.bufferAfterMs ?? 0);
+    const bufferBeforeMs = bookingBufferBeforeMs(rules);
     const step = rules?.slotStepMinutes;
+    const offset = stepOffset(rules);
+    const toStep = step === undefined ? undefined : (from) => nextStepStart(from, step, params.timezone, offset);
     const searched = { start: new Date(start), end: new Date(end) };
     if (rules?.maxAdvanceDays !== undefined) {
         // The latest allowed start bounds where a slot may start; it may still end after it.
         const latestStart = now.getTime() + rules.maxAdvanceDays * DAY_MINUTES * MINUTE_MS;
         if (latestStart < start || end <= start)
             return null;
-        const align = step === undefined ? undefined : (from) => nextStepStart(from, step, params.timezone);
         return {
             window: searched,
             bufferAfterMs,
+            bufferBeforeMs,
             align: (from) => {
-                const aligned = align ? align(from) : from;
+                const aligned = toStep ? toStep(from) : from;
                 // Past the latest start, no slot: move it beyond the window so it cannot fit.
                 return aligned.getTime() > latestStart ? new Date(end + 1) : aligned;
             },
@@ -143,7 +212,28 @@ export function bookingSearch(params) {
     }
     if (end <= start)
         return null;
-    return step === undefined
-        ? { window: searched, bufferAfterMs }
-        : { window: searched, bufferAfterMs, align: (from) => nextStepStart(from, step, params.timezone) };
+    return toStep === undefined
+        ? { window: searched, bufferAfterMs, bufferBeforeMs }
+        : { window: searched, bufferAfterMs, bufferBeforeMs, align: toStep };
+}
+/**
+ * The time a search must read as free or busy: its window, widened by the buffers a slot in it
+ * keeps (before its first start and after its last end).
+ */
+export function bookingSearchReach(search) {
+    return {
+        start: new Date(search.window.start.getTime() - search.bufferBeforeMs),
+        end: new Date(search.window.end.getTime() + search.bufferAfterMs),
+    };
+}
+/**
+ * Busy time as the slot times it rules out. A slot [s, s + d) keeping buffers occupies
+ * [s - before, s + d + after), so it meets busy [b, e) exactly when [s, s + d) meets
+ * [b - after, e + before): the database refuses the same booking.
+ */
+export function bookingSearchBlocked(busy, search) {
+    return busy.map((interval) => ({
+        start: new Date(interval.start.getTime() - search.bufferAfterMs),
+        end: new Date(interval.end.getTime() + search.bufferBeforeMs),
+    }));
 }

package/change-watch.d.ts

@@ -0,0 +1,56 @@
+/** What a reader needs from a change: the calendar resource it touched, if any. */
+export interface SlotlockAgentChange {
+    resourceId: string | null;
+}
+/**
+ * A tenant's change feed, as the agent server follows it (SlotlockEventFeed.listChanges, read under
+ * the tenant's row-level security). Every call names one tenant, the one whose subscribers are
+ * waiting, and must return that tenant's changes only.
+ */
+export interface SlotlockAgentChangeSource {
+    /** A position at or before every change that has not ended yet: where a new reader starts. */
+    head(tenantRef: string): Promise<string>;
+    listChanges(params: {
+        tenantRef: string;
+        after: string;
+        limit: number;
+    }): Promise<{
+        ok: true;
+        changes: readonly SlotlockAgentChange[];
+        next: string;
+    } | {
+        ok: false;
+        code: string;
+    }>;
+    /**
+     * Optional, for a custom source that learns of new changes itself: call `wake` whenever the
+     * tenant's feed may have grown, until the returned stop function is called. A wake carries nothing
+     * but itself, and reads stay at least SLOTLOCK_FEED_BUSY_MS apart. Without it (the store's own
+     * source) the feed is polled. If it throws or rejects, the reader polls instead.
+     */
+    watch?(tenantRef: string, wake: () => void): Promise<() => unknown>;
+}
+/** One subscription's interest in its tenant's feed. */
+export interface SlotlockChangeWatcher {
+    readonly resourceIds: ReadonlySet<string>;
+    /** Some of its resources changed (a change with no resource counts for every one). */
+    touched(): void;
+    /** The cursor expired: changes may have been missed, so every resource is announced once. */
+    resync(): void;
+}
+/**
+ * How soon a tenant's feed is read again after a read that found changes, in ms; also the least time
+ * between the starts of two reads of one tenant's feed, however often it is woken.
+ */
+export declare const SLOTLOCK_FEED_BUSY_MS = 250;
+/** How often a quiet tenant's feed is read, in ms: the poll backs off to this from the busy rate. */
+export declare const SLOTLOCK_FEED_IDLE_MS = 1000;
+/**
+ * The readers of one server process. `join` adds a watcher to its tenant's reader (starting it) and
+ * returns the function that removes it (stopping the reader with its last watcher).
+ */
+export declare function createSlotlockChangeReaders(source: SlotlockAgentChangeSource, onError?: (error: unknown) => void): {
+    join(tenantRef: string, watcher: SlotlockChangeWatcher): () => void;
+    /** Tenants with a reader now. */
+    readonly size: number;
+};

package/change-watch.js

@@ -0,0 +1,213 @@
+// Following a tenant's change feed for live updates (RFC 0002 P1-5): one reader per tenant per
+// server, shared by every open subscription of that tenant, that reads the feed by cursor and tells
+// each subscription which of its resources a change touched. It polls the feed on a short adaptive
+// interval: SLOTLOCK_FEED_BUSY_MS after a read that found changes, backing off to
+// SLOTLOCK_FEED_IDLE_MS when quiet, so one tenant with open subscriptions costs one indexed query per
+// interval. A reader knows only its own tenant: it reads that tenant's feed and tells that tenant's
+// watchers. Its reads and callbacks run outside any request's async context.
+import { AsyncResource } from 'node:async_hooks';
+/** Changes read per page. */
+const FEED_PAGE = 500;
+/**
+ * How soon a tenant's feed is read again after a read that found changes, in ms; also the least time
+ * between the starts of two reads of one tenant's feed, however often it is woken.
+ */
+export const SLOTLOCK_FEED_BUSY_MS = 250;
+/** How often a quiet tenant's feed is read, in ms: the poll backs off to this from the busy rate. */
+export const SLOTLOCK_FEED_IDLE_MS = 1_000;
+/** How often a quiet feed is read while a custom source's `watch` is listening, in ms. */
+const FEED_LISTENING_IDLE_MS = 15_000;
+function unref(timer) {
+    timer.unref?.();
+    return timer;
+}
+/**
+ * The readers of one server process. `join` adds a watcher to its tenant's reader (starting it) and
+ * returns the function that removes it (stopping the reader with its last watcher).
+ */
+export function createSlotlockChangeReaders(source, onError = () => { }) {
+    const readers = new Map();
+    // Created with the server, outside any request: a reader shared by many subscriptions must not run
+    // its reads and its watchers' callbacks in the async context of whichever request started it.
+    const scope = new AsyncResource('SlotlockChangeReader');
+    function schedule(tenantRef, reader, delay) {
+        if (reader.closed)
+            return;
+        clearTimeout(reader.timer);
+        reader.timer = unref(setTimeout(() => void read(tenantRef, reader), delay));
+    }
+    function stop(tenantRef, reader) {
+        reader.closed = true;
+        clearTimeout(reader.timer);
+        if (readers.get(tenantRef) === reader)
+            readers.delete(tenantRef);
+        try {
+            Promise.resolve(reader.stopWatch?.()).catch(onError);
+        }
+        catch (error) {
+            onError(error);
+        }
+    }
+    async function read(tenantRef, reader) {
+        if (reader.closed)
+            return;
+        if (reader.reading) {
+            reader.again = true;
+            return;
+        }
+        const wait = reader.lastStart + SLOTLOCK_FEED_BUSY_MS - Date.now();
+        if (wait > 0) {
+            // Too soon after the last read began: read once when the spacing is up.
+            schedule(tenantRef, reader, wait);
+            return;
+        }
+        reader.lastStart = Date.now();
+        reader.reading = true;
+        clearTimeout(reader.timer);
+        const joined = [...reader.joined];
+        reader.joined.clear();
+        const idle = reader.listening ? FEED_LISTENING_IDLE_MS : SLOTLOCK_FEED_IDLE_MS;
+        let found = false;
+        try {
+            let touched = new Set();
+            let expired = false;
+            if (reader.cursor === undefined)
+                reader.cursor = await source.head(tenantRef);
+            // The reader's cursor moves only once every page is read and its watchers are about to be
+            // told: a page that fails leaves it where it was, so the next read sees those changes again.
+            let cursor = reader.cursor;
+            for (let page = 0; page < 20 && !reader.closed; page += 1) {
+                const result = await source.listChanges({
+                    tenantRef,
+                    after: cursor,
+                    limit: FEED_PAGE,
+                });
+                if (!result.ok) {
+                    // Too far behind (or a cursor no store knows): start again from now, and since changes
+                    // may have been missed, announce every watched resource once.
+                    cursor = await source.head(tenantRef);
+                    expired = true;
+                    break;
+                }
+                cursor = result.next;
+                for (const change of result.changes) {
+                    if (touched === 'all')
+                        break;
+                    if (change.resourceId === null)
+                        touched = 'all';
+                    else
+                        touched.add(change.resourceId);
+                }
+                if (result.changes.length > 0)
+                    found = true;
+                if (result.changes.length < FEED_PAGE)
+                    break;
+            }
+            if (reader.closed)
+                return;
+            reader.cursor = cursor;
+            const told = new Set();
+            for (const watcher of reader.watchers) {
+                if (expired) {
+                    watcher.resync();
+                    told.add(watcher);
+                    continue;
+                }
+                if (touched === 'all' || [...watcher.resourceIds].some((id) => touched.has(id))) {
+                    watcher.touched();
+                    told.add(watcher);
+                }
+            }
+            // A watcher's first read was before this one began, so whatever committed in between is
+            // below the cursor now: it reads once more to see it.
+            for (const watcher of joined) {
+                if (!told.has(watcher) && reader.watchers.has(watcher))
+                    watcher.touched();
+            }
+            reader.delay = found
+                ? SLOTLOCK_FEED_BUSY_MS
+                : Math.min(Math.max(reader.delay * 2, SLOTLOCK_FEED_BUSY_MS), idle);
+        }
+        catch (error) {
+            onError(error);
+            for (const watcher of joined)
+                reader.joined.add(watcher);
+            reader.delay = idle;
+        }
+        finally {
+            reader.reading = false;
+        }
+        if (reader.closed)
+            return;
+        if (reader.again) {
+            reader.again = false;
+            schedule(tenantRef, reader, 0);
+        }
+        else {
+            schedule(tenantRef, reader, reader.delay);
+        }
+    }
+    function join(tenantRef, watcher) {
+        let reader = readers.get(tenantRef);
+        if (!reader) {
+            const created = {
+                watchers: new Set(),
+                joined: new Set(),
+                reading: false,
+                again: false,
+                closed: false,
+                listening: false,
+                delay: SLOTLOCK_FEED_BUSY_MS,
+                lastStart: 0,
+            };
+            reader = created;
+            readers.set(tenantRef, created);
+            const { watch } = source;
+            if (watch) {
+                // A wake comes in whatever context the source calls it from; the read runs in the reader's.
+                const wake = scope.bind(() => {
+                    // A wake while quiet reads at once; a read under way reads again when it ends.
+                    if (!created.closed)
+                        void read(tenantRef, created);
+                });
+                // A source that throws, rejects or returns no stop function leaves the reader polling.
+                Promise.resolve()
+                    .then(() => watch.call(source, tenantRef, wake))
+                    .then((stopWatch) => {
+                    if (typeof stopWatch !== 'function') {
+                        throw new Error('slotlock: subscriptions.changes.watch returned no stop function');
+                    }
+                    if (created.closed) {
+                        return Promise.resolve(stopWatch()).then(() => undefined);
+                    }
+                    created.stopWatch = stopWatch;
+                    created.listening = true;
+                    return undefined;
+                })
+                    .catch(onError);
+            }
+        }
+        const current = reader;
+        current.watchers.add(watcher);
+        current.joined.add(watcher);
+        void read(tenantRef, current);
+        let left = false;
+        return () => {
+            if (left)
+                return;
+            left = true;
+            current.watchers.delete(watcher);
+            current.joined.delete(watcher);
+            if (current.watchers.size === 0)
+                stop(tenantRef, current);
+        };
+    }
+    return {
+        get size() {
+            return readers.size;
+        },
+        join(tenantRef, watcher) {
+            return scope.runInAsyncScope(() => join(tenantRef, watcher));
+        },
+    };
+}

package/dashboard.d.ts

@@ -5,7 +5,7 @@ import { type SlotlockRate } from './config.js';
 import { type SlotlockBookingRules } from './booking-rules.js';
 import { type CreateWebhookEndpointResult, type SlotlockChange, type SlotlockWebhookEndpoint } from './event-feed.js';
 import type { SlotlockSql, SlotlockStore, SlotlockWaitlistEntry } from './store.js';
-import type { Interval, SlotlockAgendaEntry, SlotlockResource, WeeklyAvailabilityRule } from './types.js';
+import type { Interval, SlotlockAgendaEntry, SlotlockResource, SlotlockBookingRuleDefaults, WeeklyAvailabilityRule } from './types.js';
 /** Resources one dashboard tenant may hold. */
 export declare const SLOTLOCK_DASHBOARD_MAX_RESOURCES = 100;
 /**
@@ -37,6 +37,8 @@ export interface SlotlockDashboardResources {
      * null when it is not the tenant's. Invalid rules throw with `code: 'invalid_booking_rules'`.
      */
     setRules?(tenantRef: string, id: string, rules: SlotlockBookingRules | null, actor?: string): Promise<SlotlockResource | null>;
+    /** The tenant's default booking rules and its pools', which a resource's own rules overlay. */
+    ruleDefaults?(tenantRef: string): Promise<SlotlockBookingRuleDefaults>;
     /** Put one of the tenant's resources in a pool, or none: as setRules; `code: 'invalid_pool'`. */
     setPool?(tenantRef: string, id: string, pool: string | null, actor?: string): Promise<SlotlockResource | null>;
     /** The tenant's waitlist, oldest first, and leaving it (false when the entry is not the tenant's). */