oneentry 1.0.155 → 1.0.157

package/dist/base/syncModules.js

@@ -91,14 +91,17 @@ class SyncModules {
         /**
          * Sorts attributes by their positions.
          *
-         * The API returns attributes as an object `{ marker: AttrObject }`.
-         * Each attribute has a `position` field. The method rebuilds the object
-         * with keys sorted by ascending `position` so that the display order
-         * matches the order defined in the CMS.
-         * @param {any} data - The data containing attributes.
-         * @returns {any} Sorted attributes.
+         * Each attribute has a `position` field, and the API returns them in no
+         * particular order. The method rebuilds the collection sorted by ascending
+         * `position`, so the display order matches the order defined in the CMS.
+         * Both container shapes the API uses are handled: an object keyed by marker
+         * (`attributeValues`) and an array (form `attributes`).
+         * @param {any} data - The attributes collection to sort.
+         * @returns {any} Sorted attributes, in the same container shape.
          */
-        this._sortAttributes = (data) => Object.fromEntries(Object.entries(data).sort(([, a], [, b]) => a.position - b.position));
+        this._sortAttributes = (data) => Array.isArray(data)
+            ? [...data].sort((a, b) => a.position - b.position)
+            : Object.fromEntries(Object.entries(data).sort(([, a], [, b]) => a.position - b.position));
         this.state = state;
         this._url = state.url;
         this._nodeDeviceId = _generateId();
@@ -240,299 +243,44 @@ class SyncModules {
         return body;
     }
     /**
-     * Clears arrays within the data structure.
-     *
-     * Traverses the data and fixes a specific edge case with image attributes:
-     * when an `image` attribute has a single-element array in `value`,
-     * the API returns an array but consumers expect a plain object.
-     * In that case `value` is unwrapped: `[img]` → `img`.
-     *
-     * For all other keys the method recursively copies the structure unchanged.
-     * @param {Record<string, any>} data - The data to clear.
-     * @returns {any} Cleared data.
-     */
-    _clearArray(data) {
-        if (Array.isArray(data)) {
-            return data.map((item) => this._clearArray(item));
-        }
-        else if (typeof data === 'object' && data) {
-            const normalizeData = {};
-            Object.keys(data).forEach((key) => {
-                if (Array.isArray(data[key])) {
-                    normalizeData[key] = this._clearArray(data[key]);
-                }
-                else if (!data[key] || typeof data[key] !== 'object') {
-                    normalizeData[key] = data[key];
-                }
-                else if (key === 'attributeValues') {
-                    const attrs = data[key];
-                    Object.keys(attrs).forEach((attr) => {
-                        // If an image attribute has a single-element value array,
-                        // unwrap it to a plain object for consumer convenience.
-                        if (attrs[attr].type === 'image' &&
-                            attrs[attr].value.length === 1) {
-                            attrs[attr].value = attrs[attr].value[0];
-                        }
-                    });
-                    normalizeData[key] = data[key];
-                }
-                else {
-                    normalizeData[key] = this._clearArray(data[key]);
-                }
-            });
-            return normalizeData;
-        }
-        else {
-            return data;
-        }
-    }
-    /**
-     * Adds a specified number of days to a date.
-     * @param {Date} date - The initial date.
-     * @param {number} days - The number of days to add.
-     * @returns {any} The new date with added days.
-     */
-    _addDays(date, days) {
-        const result = new Date(date);
-        result.setUTCDate(result.getUTCDate() + days);
-        return result;
-    }
-    /**
-     * Common logic for processing schedule dates (weekly, monthly, or both).
-     *
-     * Abstracts date iteration for three scheduling modes:
-     *
-     * - **`inEveryWeek` only**: starting from the start date, generates dates
-     * with a 7-day step until the end of the current month.
-     *
-     * - **`inEveryMonth` only**: pins the day-of-month from the start date
-     * and repeats it for each of the next 12 months. If the month does not
-     * have that day (e.g. Feb 31), the iteration is skipped.
-     *
-     * - **`inEveryWeek` + `inEveryMonth`**: for each of the next 12 months finds
-     * the first occurrence of the target weekday (from the start date), then
-     * iterates all occurrences of that weekday in the month with a 7-day step.
-     *
-     * `processDate(currentDate)` is called for every resolved date.
-     * @param {Date} date - The date for which to process intervals.
-     * @param {object} config - Configuration for schedule repetition.
-     * @param {boolean} config.inEveryWeek - Whether to repeat weekly.
-     * @param {boolean} config.inEveryMonth - Whether to repeat monthly.
-     * @param {(currentDate: Date) => void} processDate - Callback function to process each date.
+     * Normalizes the value of a single attribute in place.
+     *
+     * Applies the three type-driven fixes the API response needs, so that an
+     * attribute of a given type always reaches the consumer in the same shape,
+     * no matter which collection it arrived in:
+     *
+     * 1. **Single-file values** (`image`, `file`) — the API always sends an array,
+     * even for one file: `[img]` → `img`. Multi-file values and `groupOfImages`
+     * (a collection by definition) stay an array.
+     * 2. **Empty values** — an attribute with no value comes back as an empty
+     * localization map `{}`; it is replaced with `null`, the same marker the
+     * numeric branch already produced.
+     * 3. **Numbers** (`integer`, `float`, `real`) — cast to a JS number; anything
+     * that is not a number (including an empty value) becomes `null`.
+     * @param {any} attr - The attribute object to normalize in place.
      */
-    _processScheduleDates(date, config, processDate) {
-        // Handle weekly schedules
-        if (config.inEveryWeek && !config.inEveryMonth) {
-            let currentDate = new Date(date);
-            // Calculate the last day of the current month
-            const endOfMonth = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, 0);
-            while (currentDate <= endOfMonth) {
-                processDate(currentDate);
-                // Move to the next week
-                currentDate = this._addDays(currentDate, 7);
-            }
+    _normalizeAttrValue(attr) {
+        if ((attr.type === 'image' || attr.type === 'file') &&
+            Array.isArray(attr.value) &&
+            attr.value.length === 1) {
+            attr.value = attr.value[0];
         }
-        // Handle monthly schedules
-        if (config.inEveryMonth && !config.inEveryWeek) {
-            const startDate = new Date(date);
-            const targetDayOfMonth = startDate.getUTCDate();
-            const numberOfMonths = 12;
-            for (let i = 0; i < numberOfMonths; i++) {
-                const currentDate = new Date(startDate);
-                currentDate.setUTCMonth(currentDate.getUTCMonth() + i);
-                // Try setting the current date to the target day of the month
-                currentDate.setUTCDate(targetDayOfMonth);
-                // Check if we have exceeded the month
-                if (currentDate.getUTCMonth() !== (startDate.getUTCMonth() + i) % 12) {
-                    continue; // Skip this month if exceeded
-                }
-                processDate(currentDate);
-            }
+        // An attribute with no value arrives as an empty localization map.
+        if (attr.value &&
+            typeof attr.value === 'object' &&
+            !Array.isArray(attr.value) &&
+            Object.keys(attr.value).length === 0) {
+            attr.value = null;
         }
-        // Handle both weekly and monthly schedules
-        if (config.inEveryMonth && config.inEveryWeek) {
-            const startDate = new Date(date);
-            const targetDayOfWeek = startDate.getUTCDay();
-            const numberOfMonths = 12;
-            for (let i = 0; i < numberOfMonths; i++) {
-                const currentDate = new Date(startDate);
-                currentDate.setUTCMonth(currentDate.getUTCMonth() + i);
-                // Set to the first day of the month
-                currentDate.setUTCDate(1);
-                // Find the first target day of the week in the current month
-                const daysUntilTargetDay = (targetDayOfWeek - currentDate.getUTCDay() + 7) % 7;
-                currentDate.setUTCDate(currentDate.getUTCDate() + daysUntilTargetDay);
-                // Iterate over all target days of the week in the current month
-                while (currentDate.getUTCMonth() ===
-                    (startDate.getUTCMonth() + i) % 12) {
-                    processDate(currentDate);
-                    // Move to the next week (same day of the week)
-                    currentDate.setUTCDate(currentDate.getUTCDate() + 7);
-                }
-            }
+        if (attr.type === 'integer' ||
+            attr.type === 'float' ||
+            attr.type === 'real') {
+            // Number(null) is 0 and Number('') is 0 — an empty value must stay empty.
+            const isEmpty = attr.value === null || attr.value === undefined || attr.value === '';
+            const numValue = isEmpty ? NaN : Number(attr.value);
+            attr.value = isNaN(numValue) ? null : numValue;
         }
     }
-    /**
-     * Generates intervals for a specific date based on a schedule.
-     *
-     * For each date resolved by `_processScheduleDates`, iterates over
-     * the `schedule.times` array of time ranges. Each range is a pair
-     * `[startTime, endTime]` with `{ hours, minutes }` fields.
-     * Creates an ISO interval `[start.toISOString(), end.toISOString()]`
-     * and adds it to `utcIntervals` (Set deduplicates automatically).
-     * @param {Date} date - The date for which to generate intervals.
-     * @param {object} schedule - The schedule defining the intervals.
-     * @param {boolean} schedule.inEveryWeek  - The number of weeks between intervals.
-     * @param {any[]} schedule.times - The times for each interval.
-     * @param {boolean} schedule.inEveryMonth - The month intervals for each interval.
-     * @param {Set<Array<string>>} utcIntervals - A set to store unique intervals.
-     */
-    _generateIntervalsForDate(date, schedule, utcIntervals) {
-        this._processScheduleDates(date, schedule, (currentDate) => {
-            schedule.times.forEach((timeRange) => {
-                const [startTime, endTime] = timeRange;
-                const intervalStart = new Date(currentDate);
-                intervalStart.setUTCHours(startTime.hours, startTime.minutes, 0, 0);
-                const intervalEnd = new Date(currentDate);
-                intervalEnd.setUTCHours(endTime.hours, endTime.minutes, 0, 0);
-                utcIntervals.add([
-                    intervalStart.toISOString(),
-                    intervalEnd.toISOString(),
-                ]);
-            });
-        });
-    }
-    /**
-     * Adds time intervals to schedules.
-     *
-     * Accepts an array of schedule groups (structure of `timeInterval` attributes
-     * for pages/products). For each group iterates over `values` — the set of
-     * concrete schedules. Each schedule contains a date range `dates[0..1]`.
-     *
-     * If both boundaries are equal (`isSameDay`), intervals are generated only
-     * for that single date. Otherwise — for every day in the range inclusive.
-     *
-     * The result (`schedule.timeIntervals`) is a sorted array of ISO pairs,
-     * ready to pass to UI components.
-     * @param {any[]} schedules - The schedules to process.
-     * @returns {any} Schedules with added time intervals.
-     */
-    _addTimeIntervalsToSchedules(schedules) {
-        schedules === null || schedules === void 0 ? void 0 : schedules.forEach((scheduleGroup) => {
-            // Skip if scheduleGroup.values is not an array
-            if (!scheduleGroup ||
-                !scheduleGroup.values ||
-                !Array.isArray(scheduleGroup.values)) {
-                return;
-            }
-            scheduleGroup.values.forEach((schedule) => {
-                const utcIntervals = new Set();
-                const startDate = new Date(schedule.dates[0]);
-                const endDate = new Date(schedule.dates[1]);
-                const isSameDay = startDate.toISOString() === endDate.toISOString();
-                if (isSameDay) {
-                    this._generateIntervalsForDate(startDate, schedule, utcIntervals);
-                }
-                else {
-                    for (let currentDate = new Date(startDate); currentDate <= endDate; currentDate = this._addDays(currentDate, 1)) {
-                        this._generateIntervalsForDate(currentDate, schedule, utcIntervals);
-                    }
-                }
-                schedule.timeIntervals = Array.from(utcIntervals).sort();
-            });
-        });
-        return schedules;
-    }
-    /**
-     * Generates intervals for a specific date for form schedules.
-     *
-     * Unlike `_generateIntervalsForDate`, time ranges here have a different shape:
-     * each `timeInterval` contains `start`, `end` and `period`
-     * (slot length in minutes). The method slices the [start, end) window into
-     * fixed-length slots of `period` minutes:
-     *
-     * start=09:00, end=12:00, period=30 → [09:00–09:30], [09:30–10:00], …, [11:30–12:00]
-     *
-     * Generation stops if the next slot would exceed `end`.
-     * Each slot is added to `utcIntervals` (Set deduplicates automatically).
-     * @param {Date} date - The date for which to generate intervals.
-     * @param {object} interval - The interval configuration.
-     * @param {boolean} interval.inEveryWeek - Indicates whether the schedule is weekly.
-     * @param {boolean} interval.inEveryMonth - Indicates whether the schedule is monthly.
-     * @param {any[]} timeIntervals - The time intervals to process.
-     * @param {Set<Array<string>>} utcIntervals - A set to store unique intervals.
-     */
-    _generateIntervalsForFormDate(date, interval, timeIntervals, utcIntervals) {
-        const generateTimeSlotsForDate = (currentDate) => {
-            timeIntervals.forEach((timeInterval) => {
-                let currentStart = timeInterval.start;
-                const endTime = timeInterval.end;
-                // Slice the window into slots of `period` minutes each.
-                while (currentStart.hours < endTime.hours ||
-                    (currentStart.hours === endTime.hours &&
-                        currentStart.minutes < endTime.minutes)) {
-                    const intervalStart = new Date(currentDate);
-                    intervalStart.setUTCHours(currentStart.hours, currentStart.minutes, 0, 0);
-                    // Compute slot end: add period minutes with hour carry normalization.
-                    const nextMinutes = currentStart.minutes + timeInterval.period;
-                    const nextHours = currentStart.hours + Math.floor(nextMinutes / 60);
-                    const minutes = nextMinutes % 60;
-                    // If the slot end exceeds `end` — stop; partial slots are not emitted.
-                    if (nextHours > endTime.hours ||
-                        (nextHours === endTime.hours && minutes > endTime.minutes)) {
-                        break;
-                    }
-                    const intervalEnd = new Date(currentDate);
-                    intervalEnd.setUTCHours(nextHours, minutes, 0, 0);
-                    utcIntervals.add([
-                        intervalStart.toISOString(),
-                        intervalEnd.toISOString(),
-                    ]);
-                    currentStart = { hours: nextHours, minutes };
-                }
-            });
-        };
-        this._processScheduleDates(date, interval, generateTimeSlotsForDate);
-    }
-    /**
-     * Adds time intervals to form schedules (different structure).
-     *
-     * Same as `_addTimeIntervalsToSchedules` but for `timeInterval` attributes
-     * in **forms** (different API data structure):
-     * - `interval.range[0..1]` instead of `schedule.dates[0..1]`
-     * - `interval.intervals` — array of time ranges with slots (`period`)
-     * instead of `[startTime, endTime]` pairs
-     *
-     * Result is written to `interval.timeIntervals`.
-     * @param {any[]} intervals - The intervals to process.
-     * @returns {any} Intervals with added time intervals.
-     */
-    _addTimeIntervalsToFormSchedules(intervals) {
-        intervals.forEach((interval) => {
-            var _a, _b;
-            if (!interval.intervals || !Array.isArray(interval.intervals)) {
-                return;
-            }
-            const utcIntervals = new Set();
-            const startDate = new Date(interval.range[0]);
-            const endDate = new Date(interval.range[1]);
-            const isSameDay = startDate.toISOString() === endDate.toISOString();
-            const intervalConfig = {
-                inEveryWeek: (_a = interval.inEveryWeek) !== null && _a !== void 0 ? _a : false,
-                inEveryMonth: (_b = interval.inEveryMonth) !== null && _b !== void 0 ? _b : false,
-            };
-            if (isSameDay) {
-                this._generateIntervalsForFormDate(startDate, intervalConfig, interval.intervals, utcIntervals);
-            }
-            else {
-                for (let currentDate = new Date(startDate); currentDate <= endDate; currentDate = this._addDays(currentDate, 1)) {
-                    this._generateIntervalsForFormDate(currentDate, intervalConfig, interval.intervals, utcIntervals);
-                }
-            }
-            interval.timeIntervals = Array.from(utcIntervals).sort();
-        });
-        return intervals;
-    }
     /**
      * Transforms additionalFields from array to object keyed by marker.
      *
@@ -553,19 +301,28 @@ class SyncModules {
      *
      * Handles three different attribute formats returned by the API:
      *
-     * **1. `attributeValues`** — attributes of pages, products and other entities.
-     * Contains an object `{ marker: AttrObject }`. For each attribute:
-     * - `_normalizeAdditionalFields` is called;
-     * - numeric types (`integer`, `float`) are cast to a JS number (or `null`);
-     * - `timeInterval` attributes are enriched with computed `timeIntervals`;
-     * - the whole object is re-sorted by `position`.
+     * All three go through the same steps, so an attribute of a given type looks
+     * the same whichever collection it arrived in:
+     * - `_normalizeAdditionalFields` turns nested fields into a marker map;
+     * - `_normalizeAttrValue` unwraps single-file values, empties to `null` and
+     * casts numbers;
+     * - the collection is re-sorted by `position`.
+     *
+     * **1. `attributeValues`** — attributes of pages, products and other entities,
+     * an object `{ marker: AttrObject }`.
+     *
+     * **2. `attributes`** — form attributes, an array (or a marker map on some
+     * endpoints); form-only boolean flags (`isLogin`, `isSignUp`, notifications)
+     * are additionally coerced from `null` to `false`.
      *
-     * **2. `attributes`** — form attributes (different API structure).
-     * Same `additionalFields` and `timeInterval` processing,
-     * but numbers are not normalized here (commented out — logic differs).
+     * **3. `type`** — a standalone attribute: an attribute-set entry, a form-data
+     * field or a nested `additionalFields` entry. Same transformations, but there
+     * is no collection to sort.
      *
-     * **3. `type`** — a single attribute from an attribute set.
-     * Same transformations as in case 1, but without sorting.
+     * `timeInterval` attributes are left exactly as the API returned them — a
+     * compact recurrence rule. Resolving one into concrete slots is the caller's
+     * job, via `expandTimeIntervals`: the rule is open-ended, so only the caller
+     * knows how wide a window it needs.
      *
      * If none of the keys are found — data is returned unchanged.
      * @param {any} data - The data to normalize.
@@ -577,20 +334,7 @@ class SyncModules {
             Object.keys(data.attributeValues).forEach((attr) => {
                 const d = data.attributeValues[attr];
                 this._normalizeAdditionalFields(d);
-                // normalize numbers
-                if (d.type === 'integer' || d.type === 'float') {
-                    const numValue = Number(d.value);
-                    d.value = isNaN(numValue) ? null : numValue;
-                }
-                // add timeIntervals
-                if (data.attributeValues[attr].type === 'timeInterval') {
-                    const schedules = data.attributeValues[attr].value;
-                    // console.log('Schedules: ', JSON.stringify(schedules));
-                    if (Array.isArray(schedules) && schedules.length > 0) {
-                        const result = this._addTimeIntervalsToSchedules(schedules);
-                        data.attributeValues[attr].value = result;
-                    }
-                }
+                this._normalizeAttrValue(d);
             });
             return {
                 ...data,
@@ -608,64 +352,28 @@ class SyncModules {
         if ('attributes' in data) {
             const d = data.attributes;
             Object.keys(d).forEach((attr) => {
-                var _a;
                 this._normalizeAdditionalFields(d[attr]);
+                this._normalizeAttrValue(d[attr]);
                 for (const field of booleanFields) {
                     if (field in d[attr] && d[attr][field] === null) {
                         d[attr][field] = false;
                     }
                 }
-                // Add time intervals
-                if (d[attr].type === 'timeInterval') {
-                    const intervals = (_a = d[attr].localizeInfos) === null || _a === void 0 ? void 0 : _a.intervals;
-                    // console.log('Schedules:: ', JSON.stringify(intervals));
-                    if (intervals && Array.isArray(intervals) && intervals.length > 0) {
-                        const result = this._addTimeIntervalsToFormSchedules(intervals);
-                        d[attr].localizeInfos.intervals = result;
-                    }
-                }
             });
-            return data;
+            return { ...data, attributes: this._sortAttributes(d) };
         }
         //  For single attribute - for attribute sets
         if ('type' in data) {
             this._normalizeAdditionalFields(data);
+            this._normalizeAttrValue(data);
             for (const field of booleanFields) {
                 if (field in data && data[field] === null) {
                     data[field] = false;
                 }
             }
-            // Normalize numbers
-            if (data.type === 'integer' || data.type === 'float') {
-                const numValue = Number(data.value);
-                data.value = isNaN(numValue) ? null : numValue;
-            }
-            // Add time intervals
-            if (data.type === 'timeInterval') {
-                const schedules = data.value;
-                if (Array.isArray(schedules) && schedules.length > 0) {
-                    const result = this._addTimeIntervalsToSchedules(schedules);
-                    data.value = result;
-                }
-            }
         }
         return data;
     }
-    /**
-     * Processes data after fetching or receiving it.
-     *
-     * Final post-processing of the API response: first unwraps localized fields
-     * (`_normalizeData`), then fixes single-element image attributes
-     * (`_clearArray`). Called at the end of every fetch method.
-     * @param {any} data - The data to process.
-     * @param {any} [langCode] - The language code for processing.
-     * @returns {any} Processed data.
-     */
-    _dataPostProcess(data, langCode = this.state.lang) {
-        const normalize = this._normalizeData(data, langCode);
-        const result = this._clearArray(normalize);
-        return result;
-    }
     /**
      * Sets the access token in the state.
      * @param {string} accessToken - The access token to set.

package/dist/base/timeIntervals.d.ts

@@ -0,0 +1,95 @@
+import type { IAttributeValue, ITimeIntervalAttributeValue, ITimeIntervalEntitySchedule, ITimeIntervalSchedule, ITimeIntervalWindow, TimeIntervalPair } from './utils';
+/**
+ * Expands a `timeInterval` schedule into concrete UTC slots for a given window.
+ *
+ * A schedule as returned by the API is a compact **recurrence rule** — an
+ * anchor date plus daily time ranges plus repeat flags — not a list of slots.
+ * Materializing it wholesale is what makes `timeInterval` attributes expensive
+ * (a year of half-hour slots runs to megabytes), so expansion is on demand and
+ * the window is required: only the caller knows how far it needs to resolve.
+ *
+ * Both schedule shapes the API returns are accepted:
+ * - **entity** — `attributeValues[marker].value[].values[]` on pages, products,
+ * blocks and attribute sets: a `dates` range with `times` pairs;
+ * - **form** — `attributes[marker].localizeInfos.intervals[]`: a `range` with
+ * `intervals` that carry a slot `period` in minutes.
+ *
+ * Semantics:
+ * - `dates[0]` / `range[0]` is both the recurrence phase and the first valid
+ * day — nothing earlier is emitted, however wide the window;
+ * - `dates[1]` / `range[1]` ends validity; when it does not extend past the
+ * start, the schedule is anchored to that day — with a recurrence flag set,
+ * recurrence is then open-ended and the window alone bounds the result;
+ * - `inEveryWeek` repeats every 7 days from the anchor; `inEveryMonth` repeats
+ * on the same day-of-month, skipping months that are too short; with both set
+ * the weekly rule applies, which is what it has always meant in practice;
+ * - with neither flag the schedule is a plain date range — every day of it;
+ * - the result is deduplicated and sorted by start, then end.
+ * @param {ITimeIntervalEntitySchedule | ITimeIntervalSchedule} schedule - A single schedule entry from a `timeInterval` attribute.
+ * @param {ITimeIntervalWindow} window - Inclusive `{ from, to }` range to resolve, compared at UTC day granularity.
+ * @returns {TimeIntervalPair[]} Sorted, deduplicated `[start, end]` ISO pairs; empty when the schedule is malformed or does not overlap the window.
+ * To expand a whole attribute at once, prefer {@link expandAttributeTimeIntervals}
+ * — it walks the groups and merges the results for you. Reach for this function
+ * directly when you already hold a single schedule, e.g. a form's
+ * `localizeInfos.intervals[]`.
+ * @example
+ * ```ts
+ * import { expandTimeIntervals } from 'oneentry';
+ *
+ * // Form attributes are an array keyed by `marker`, and carry their schedules
+ * // already typed on `localizeInfos.intervals`.
+ * const field = form.attributes.find((a) => a.marker === 'booking');
+ *
+ * const slots = (field?.localizeInfos.intervals ?? []).flatMap((schedule) =>
+ *     expandTimeIntervals(schedule, { from: '2025-05-01', to: '2025-05-31' }),
+ * );
+ * // [['2025-05-07T09:00:00.000Z', '2025-05-07T10:00:00.000Z'], …]
+ * ```
+ */
+export declare function expandTimeIntervals(schedule: ITimeIntervalEntitySchedule | ITimeIntervalSchedule, window: ITimeIntervalWindow): TimeIntervalPair[];
+/**
+ * Narrows an attribute value to a `timeInterval` attribute.
+ *
+ * `IAttributeValue.value` is `unknown` — its shape depends on `type` — so this
+ * guard is what lets you reach the schedules without a cast.
+ * @param {IAttributeValue | undefined} attr - The attribute value to test.
+ * @returns {boolean} True when the attribute is a `timeInterval` carrying an array of groups.
+ * @example
+ * ```ts
+ * const attr = page.attributeValues.interval;
+ * if (isTimeIntervalAttribute(attr)) {
+ *     attr.value[0].values[0].dates; // fully typed, no cast
+ * }
+ * ```
+ */
+export declare function isTimeIntervalAttribute(attr: IAttributeValue | undefined): attr is ITimeIntervalAttributeValue;
+/**
+ * Expands a whole `timeInterval` attribute into concrete UTC slots for a window.
+ *
+ * The one-call path for the common case: it walks the attribute's groups and
+ * their schedules, expands each with {@link expandTimeIntervals}, and merges the
+ * results. Merging matters — deduplication and ordering only hold within a
+ * single schedule, so combining groups by hand can yield duplicate or unsorted
+ * slots.
+ *
+ * Anything that is not a `timeInterval` attribute yields an empty array, so this
+ * is safe to call on an arbitrary attribute without checking `type` first.
+ *
+ * For **form** attributes the schedules are already typed at
+ * `localizeInfos.intervals`, so no equivalent helper is needed — map over them
+ * and call {@link expandTimeIntervals} directly.
+ * @param {IAttributeValue | undefined} attr - A `timeInterval` attribute value, e.g. `page.attributeValues.interval`.
+ * @param {ITimeIntervalWindow} window - Inclusive `{ from, to }` range to resolve, compared at UTC day granularity.
+ * @returns {TimeIntervalPair[]} Sorted, deduplicated `[start, end]` ISO pairs across every group; empty when the attribute is not a `timeInterval`.
+ * @example
+ * ```ts
+ * import { expandAttributeTimeIntervals } from 'oneentry';
+ *
+ * const slots = expandAttributeTimeIntervals(page.attributeValues.interval, {
+ *     from: '2025-04-01',
+ *     to: '2025-04-30',
+ * });
+ * // [['2025-04-14T09:00:00.000Z', '2025-04-14T10:00:00.000Z'], …]
+ * ```
+ */
+export declare function expandAttributeTimeIntervals(attr: IAttributeValue | undefined, window: ITimeIntervalWindow): TimeIntervalPair[];