@purespectrum1/purescore-client 0.7.0

package/lib/domain/services/single-script-injection/schedule-store.d.ts

@@ -0,0 +1,69 @@
+import { ScheduleCheckpoint, ScheduleRecord } from '../../protocols/services/single-script-injection/auto-init';
+import { GetStorage, RemoveStorage, SetStorage } from '../../protocols/cache';
+/**
+ * How long a record outlives its final checkpoint. A respondent who comes back
+ * the next day gets a fresh schedule, not one long overdue.
+ */
+export declare const SCHEDULE_TTL_MS = 3600000;
+/** The first call does not wait for the LOI. */
+export declare const INITIAL_CHECKPOINT_DELAY_MS = 10000;
+/** The later checkpoints, as multiples of the LOI. */
+export declare const LOI_CHECKPOINT_FRACTIONS: readonly [number, number, 1, 2];
+/** Most calls a transaction can make: the initial one plus each LOI fraction. */
+export declare const CHECKPOINT_COUNT: number;
+/**
+ * Owns the `ps_di_schedule_<surveyId>` record: which checkpoints are still
+ * outstanding on a later page load. Storage is injected, so this holds only the
+ * schedule rules, not where the record lives.
+ */
+export declare class ScheduleStore {
+    private readonly surveyId;
+    private readonly storage;
+    constructor(surveyId: string, storage: GetStorage & SetStorage & RemoveStorage);
+    get key(): string;
+    /**
+     * Checkpoint 1 fires `INITIAL_CHECKPOINT_DELAY_MS` in regardless; the rest are
+     * LOI multiples, so an unknown LOI yields a one-checkpoint schedule rather
+     * than none. At LOI 6 min: T+10s, T+120s, T+240s, T+360s, T+720s.
+     */
+    static buildCheckpoints(startedAt: number, loi: number | null): ScheduleCheckpoint[];
+    /** The record is kept until an hour past the last call it still owes. */
+    private static expiryFor;
+    /**
+     * Reads the record for this transaction, or null when it is absent, unreadable
+     * or expired. Anything unusable is evicted rather than driven off, so the next
+     * `resumeOrCreate` starts a clean schedule.
+     */
+    read(): ScheduleRecord | null;
+    /**
+     * Returns the existing record for this transaction, or creates one when the
+     * transaction has not been seen on this origin yet.
+     *
+     * Resuming deliberately keeps the stored `startedAt` and `checkpoints`: the
+     * checkpoints stay on the clock started by the very first page load, so a
+     * respondent cannot reset the schedule by reloading.
+     */
+    resumeOrCreate(): ScheduleRecord;
+    /**
+     * Adds the LOI-derived checkpoints, measured from the original `startedAt` so
+     * applying the LOI later does not push the schedule back. Ignored when an LOI
+     * is already set — renumbering could disturb sent calls.
+     */
+    applyLoi(loi: number): ScheduleRecord | null;
+    /**
+     * Marks checkpoint `n` as delivered. Written as a max so an out-of-order
+     * write — two tabs firing around the same due time — can never lower the
+     * counter and re-open a checkpoint that already went out.
+     */
+    markSent(n: number): ScheduleRecord | null;
+    /**
+     * Stores the latest Device-Intelligence response alongside the schedule so it
+     * can be replayed on the next page load.
+     */
+    storeResponse(response: Record<string, any>): void;
+    /**
+     * Stores the transaction id returned alongside the schedule.
+     */
+    storeTransactionId(transactionId: string): void;
+    private now;
+}

package/lib/domain/services/single-script-injection/schedule-store.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleStore = exports.CHECKPOINT_COUNT = exports.LOI_CHECKPOINT_FRACTIONS = exports.INITIAL_CHECKPOINT_DELAY_MS = exports.SCHEDULE_TTL_MS = void 0;
+const validation_1 = require("../../../validation");
+/**
+ * How long a record outlives its final checkpoint. A respondent who comes back
+ * the next day gets a fresh schedule, not one long overdue.
+ */
+exports.SCHEDULE_TTL_MS = 3600000; // 1 hour
+/** The first call does not wait for the LOI. */
+exports.INITIAL_CHECKPOINT_DELAY_MS = 10000; // 10 seconds
+/** The later checkpoints, as multiples of the LOI. */
+exports.LOI_CHECKPOINT_FRACTIONS = [1 / 3, 2 / 3, 1, 2];
+/** Most calls a transaction can make: the initial one plus each LOI fraction. */
+exports.CHECKPOINT_COUNT = 1 + exports.LOI_CHECKPOINT_FRACTIONS.length;
+/**
+ * Owns the `ps_di_schedule_<surveyId>` record: which checkpoints are still
+ * outstanding on a later page load. Storage is injected, so this holds only the
+ * schedule rules, not where the record lives.
+ */
+class ScheduleStore {
+    constructor(surveyId, storage) {
+        this.surveyId = surveyId;
+        this.storage = storage;
+    }
+    get key() {
+        return `ps_di_schedule_${this.surveyId}`;
+    }
+    /**
+     * Checkpoint 1 fires `INITIAL_CHECKPOINT_DELAY_MS` in regardless; the rest are
+     * LOI multiples, so an unknown LOI yields a one-checkpoint schedule rather
+     * than none. At LOI 6 min: T+10s, T+120s, T+240s, T+360s, T+720s.
+     */
+    static buildCheckpoints(startedAt, loi) {
+        const checkpoints = [
+            { n: 1, dueAt: startedAt + exports.INITIAL_CHECKPOINT_DELAY_MS },
+        ];
+        if (loi !== null) {
+            const loiMs = loi * 60000;
+            exports.LOI_CHECKPOINT_FRACTIONS.forEach((fraction, i) => {
+                checkpoints.push({ n: i + 2, dueAt: startedAt + loiMs * fraction });
+            });
+        }
+        return checkpoints;
+    }
+    /** The record is kept until an hour past the last call it still owes. */
+    static expiryFor(checkpoints) {
+        return Math.max(...checkpoints.map(c => c.dueAt)) + exports.SCHEDULE_TTL_MS;
+    }
+    /**
+     * Reads the record for this transaction, or null when it is absent, unreadable
+     * or expired. Anything unusable is evicted rather than driven off, so the next
+     * `resumeOrCreate` starts a clean schedule.
+     */
+    read() {
+        const record = this.storage.get(this.key);
+        const isUnusable = !record
+            || new validation_1.ScheduleRecordShape(record, this.key).validate() !== undefined
+            || record.expiry <= this.now();
+        if (isUnusable) {
+            this.storage.remove(this.key);
+            return null;
+        }
+        return record;
+    }
+    /**
+     * Returns the existing record for this transaction, or creates one when the
+     * transaction has not been seen on this origin yet.
+     *
+     * Resuming deliberately keeps the stored `startedAt` and `checkpoints`: the
+     * checkpoints stay on the clock started by the very first page load, so a
+     * respondent cannot reset the schedule by reloading.
+     */
+    resumeOrCreate() {
+        const existing = this.read();
+        if (existing)
+            return existing;
+        const startedAt = this.now();
+        const checkpoints = ScheduleStore.buildCheckpoints(startedAt, null);
+        const record = {
+            surveyId: this.surveyId,
+            loi: null,
+            startedAt,
+            checkpoints,
+            sent: 0,
+            expiry: ScheduleStore.expiryFor(checkpoints),
+            lastResponse: null,
+            transactionId: null,
+        };
+        this.storage.set(this.key, record);
+        return record;
+    }
+    /**
+     * Adds the LOI-derived checkpoints, measured from the original `startedAt` so
+     * applying the LOI later does not push the schedule back. Ignored when an LOI
+     * is already set — renumbering could disturb sent calls.
+     */
+    applyLoi(loi) {
+        const record = this.read();
+        if (!record || record.loi !== null)
+            return record;
+        record.loi = loi;
+        record.checkpoints = ScheduleStore.buildCheckpoints(record.startedAt, loi);
+        record.expiry = ScheduleStore.expiryFor(record.checkpoints);
+        this.storage.set(this.key, record);
+        return record;
+    }
+    /**
+     * Marks checkpoint `n` as delivered. Written as a max so an out-of-order
+     * write — two tabs firing around the same due time — can never lower the
+     * counter and re-open a checkpoint that already went out.
+     */
+    markSent(n) {
+        const record = this.read();
+        if (!record)
+            return null;
+        record.sent = Math.max(record.sent, n);
+        this.storage.set(this.key, record);
+        return record;
+    }
+    /**
+     * Stores the latest Device-Intelligence response alongside the schedule so it
+     * can be replayed on the next page load.
+     */
+    storeResponse(response) {
+        const record = this.read();
+        if (!record)
+            return;
+        record.lastResponse = response;
+        this.storage.set(this.key, record);
+    }
+    /**
+     * Stores the transaction id returned alongside the schedule.
+     */
+    storeTransactionId(transactionId) {
+        const record = this.read();
+        if (!record)
+            return;
+        record.transactionId = transactionId;
+        this.storage.set(this.key, record);
+    }
+    now() {
+        return new Date().getTime();
+    }
+}
+exports.ScheduleStore = ScheduleStore;

package/lib/domain/services/snapshot-store.d.ts

@@ -0,0 +1,19 @@
+import { GetStorage, RemoveStorage, SetStorage } from '../protocols/cache';
+/**
+ * Keeps a snapshot of live in-memory state mirrored into storage on a timer, so
+ * a page navigation can resume from it. Polling rather than writing on change:
+ * the state it mirrors is updated by high-frequency input events, and a write
+ * per event would cost far more than a write per tick.
+ */
+export declare class SnapshotStore<T extends object> {
+    private readonly key;
+    private readonly getData;
+    private readonly storage;
+    private readonly intervalMs;
+    private interval;
+    constructor(key: string, getData: () => T, storage: GetStorage & SetStorage & RemoveStorage, intervalMs?: number);
+    start(): void;
+    stop(): void;
+    read(): T | null;
+    clear(): void;
+}

package/lib/domain/services/snapshot-store.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotStore = void 0;
+const DEFAULT_PERSIST_INTERVAL_MS = 100;
+/**
+ * Keeps a snapshot of live in-memory state mirrored into storage on a timer, so
+ * a page navigation can resume from it. Polling rather than writing on change:
+ * the state it mirrors is updated by high-frequency input events, and a write
+ * per event would cost far more than a write per tick.
+ */
+class SnapshotStore {
+    constructor(key, getData, storage, intervalMs = DEFAULT_PERSIST_INTERVAL_MS) {
+        this.key = key;
+        this.getData = getData;
+        this.storage = storage;
+        this.intervalMs = intervalMs;
+        this.interval = null;
+    }
+    start() {
+        this.stop();
+        this.interval = setInterval(() => this.storage.set(this.key, this.getData()), this.intervalMs);
+    }
+    stop() {
+        if (this.interval !== null) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    read() {
+        return this.storage.get(this.key);
+    }
+    clear() {
+        this.storage.remove(this.key);
+    }
+}
+exports.SnapshotStore = SnapshotStore;

package/lib/domain/services/spa-navigation.d.ts

@@ -0,0 +1,15 @@
+type NavigationHandler = () => void;
+/**
+ * Detects SPA navigations (back/forward, hash changes, pushState/replaceState)
+ * so consumers can re-run logic that would otherwise only run on full page loads.
+ *
+ * Browser frameworks like Next.js, Nuxt, and SvelteKit perform client-side
+ * routing that doesn't reload the JS module, leaving any setTimeout-based
+ * collection windows running against stale state. Hooking into the History API
+ * lets us reset that window when the URL actually changes.
+ */
+export declare class SpaNavigationDetector {
+    private static installed;
+    install(handler: NavigationHandler): void;
+}
+export {};

package/lib/domain/services/spa-navigation.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpaNavigationDetector = void 0;
+/**
+ * Detects SPA navigations (back/forward, hash changes, pushState/replaceState)
+ * so consumers can re-run logic that would otherwise only run on full page loads.
+ *
+ * Browser frameworks like Next.js, Nuxt, and SvelteKit perform client-side
+ * routing that doesn't reload the JS module, leaving any setTimeout-based
+ * collection windows running against stale state. Hooking into the History API
+ * lets us reset that window when the URL actually changes.
+ */
+class SpaNavigationDetector {
+    install(handler) {
+        if (SpaNavigationDetector.installed)
+            return;
+        if (typeof window === 'undefined' || typeof history === 'undefined')
+            return;
+        SpaNavigationDetector.installed = true;
+        window.addEventListener('popstate', handler);
+        window.addEventListener('hashchange', handler);
+        try {
+            const origPush = history.pushState.bind(history);
+            history.pushState = (...args) => {
+                origPush(...args);
+                handler();
+            };
+            const origReplace = history.replaceState.bind(history);
+            history.replaceState = (...args) => {
+                origReplace(...args);
+                handler();
+            };
+        }
+        catch (_a) {
+            // history may be sealed in some envs; popstate/hashchange still work
+        }
+    }
+}
+exports.SpaNavigationDetector = SpaNavigationDetector;
+SpaNavigationDetector.installed = false;

package/lib/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Public entry point of the bundle.
+ *
+ * Two responsibilities and nothing else: re-export what consumers are allowed to
+ * reach, and run the self-initializing script tag. Everything with behaviour
+ * lives behind a layer — `application` for the Device-Identifier and the
+ * bootstrap that drives it, `domain` for the services they are built from,
+ * `validation` for the rules.
+ */
+import { DeviceIdentifier } from './application/device-identifier';
+export { DeviceIdentifier };
+/**
+ * Public type surface, so `@purespectrum1/device-identifier` is the only import
+ * path consumers need. The deep `lib/domain/...` paths still work, but they are
+ * no longer part of the contract.
+ */
+export type { DeviceIdentifierOptions, DeviceIdentifierConfig, DeviceIdentifierMetadata, TrackDetails, TrackDetailsContext, TransactionDetails, CreateTransaction, } from './domain/protocols/services/device-identifier';
+export type { DisplayChecks, DisplayChecksInput, Language, NavigatorUABrandVersion, UADataValues, NavigatorUAData, NetworkInformation, UAParserDeviceType, NavigationTiming, NetworkTimes, } from './domain/protocols/services/device-fingerprint';
+export type { AutoInitConfig, ScheduleRecord, ScheduleCheckpoint, } from './domain/protocols/services/single-script-injection';

package/lib/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceIdentifier = void 0;
+/**
+ * Public entry point of the bundle.
+ *
+ * Two responsibilities and nothing else: re-export what consumers are allowed to
+ * reach, and run the self-initializing script tag. Everything with behaviour
+ * lives behind a layer — `application` for the Device-Identifier and the
+ * bootstrap that drives it, `domain` for the services they are built from,
+ * `validation` for the rules.
+ */
+const device_identifier_1 = require("./application/device-identifier");
+Object.defineProperty(exports, "DeviceIdentifier", { enumerable: true, get: function () { return device_identifier_1.DeviceIdentifier; } });
+const auto_init_1 = require("./application/auto-init");
+/**
+ * Self-initializing script tag.
+ *
+ * When the tag that loaded this bundle carries `data-auto-init="true"`, the
+ * bundle bootstraps itself from its own `data-*` attributes and drives the three
+ * Device-Intelligence calls off an LOI-derived schedule — the buyer writes no
+ * bootstrap code and no `trackDetails` call at all.
+ *
+ * Without that attribute this is a no-op, which is what keeps the existing
+ * integration path unchanged.
+ */
+new auto_init_1.AutoInitService(config => new device_identifier_1.DeviceIdentifier({ singleScriptInjection: true }, { token: config.token, env: config.env })).run();

package/lib/infra/cache/index.d.ts

@@ -0,0 +1,3 @@
+export * from './web-storage-adapter';
+export * from './local-storage-adapter';
+export * from './session-storage-adapter';

package/lib/infra/cache/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./web-storage-adapter"), exports);
+__exportStar(require("./local-storage-adapter"), exports);
+__exportStar(require("./session-storage-adapter"), exports);

package/lib/infra/cache/local-storage-adapter.d.ts

@@ -0,0 +1,8 @@
+import { WebStorageAdapter } from './web-storage-adapter';
+/**
+ * Persists across pages, tabs and browser restarts. Used for records that must
+ * outlive the tab, such as the checkpoint schedule.
+ */
+export declare class LocalStorageAdapter extends WebStorageAdapter {
+    protected store(): Storage;
+}

package/lib/infra/cache/local-storage-adapter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorageAdapter = void 0;
+const web_storage_adapter_1 = require("./web-storage-adapter");
+/**
+ * Persists across pages, tabs and browser restarts. Used for records that must
+ * outlive the tab, such as the checkpoint schedule.
+ */
+class LocalStorageAdapter extends web_storage_adapter_1.WebStorageAdapter {
+    store() {
+        return localStorage;
+    }
+}
+exports.LocalStorageAdapter = LocalStorageAdapter;

package/lib/infra/cache/session-storage-adapter.d.ts

@@ -0,0 +1,8 @@
+import { WebStorageAdapter } from './web-storage-adapter';
+/**
+ * Scoped to the tab and cleared when it closes. Used for state that should not
+ * survive the session, such as the in-progress behavioural-biometrics buffers.
+ */
+export declare class SessionStorageAdapter extends WebStorageAdapter {
+    protected store(): Storage;
+}

package/lib/infra/cache/session-storage-adapter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionStorageAdapter = void 0;
+const web_storage_adapter_1 = require("./web-storage-adapter");
+/**
+ * Scoped to the tab and cleared when it closes. Used for state that should not
+ * survive the session, such as the in-progress behavioural-biometrics buffers.
+ */
+class SessionStorageAdapter extends web_storage_adapter_1.WebStorageAdapter {
+    store() {
+        return sessionStorage;
+    }
+}
+exports.SessionStorageAdapter = SessionStorageAdapter;

package/lib/infra/cache/web-storage-adapter.d.ts

@@ -0,0 +1,13 @@
+import { GetStorage, RemoveStorage, SetStorage } from '../../domain/protocols/cache';
+/**
+ * Shared behaviour of the Web Storage adapters. Owns serialization, so callers
+ * pass objects, and availability: access throws in private modes and disabled
+ * WebViews, so failures degrade to "nothing stored" instead of reaching the page.
+ */
+export declare abstract class WebStorageAdapter implements GetStorage, SetStorage, RemoveStorage {
+    /** Resolved per operation, inside the guard — merely naming it can throw. */
+    protected abstract store(): Storage;
+    get(key: string): any;
+    set(key: string, value: object): void;
+    remove(key: string): void;
+}

package/lib/infra/cache/web-storage-adapter.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebStorageAdapter = void 0;
+/**
+ * Shared behaviour of the Web Storage adapters. Owns serialization, so callers
+ * pass objects, and availability: access throws in private modes and disabled
+ * WebViews, so failures degrade to "nothing stored" instead of reaching the page.
+ */
+class WebStorageAdapter {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get(key) {
+        try {
+            const raw = this.store().getItem(key);
+            return raw ? JSON.parse(raw) : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    set(key, value) {
+        try {
+            this.store().setItem(key, JSON.stringify(value));
+        }
+        catch ( /* storage disabled or full — the value simply does not persist */_a) { /* storage disabled or full — the value simply does not persist */ }
+    }
+    remove(key) {
+        try {
+            this.store().removeItem(key);
+        }
+        catch ( /* storage disabled — there is nothing to remove */_a) { /* storage disabled — there is nothing to remove */ }
+    }
+}
+exports.WebStorageAdapter = WebStorageAdapter;

package/lib/infra/http/axios-http-client.d.ts

@@ -0,0 +1,4 @@
+import { HttpRequest, HttpResponse, HttpClient } from '../../domain/protocols/http/http-client';
+export declare class AxiosHttpClient implements HttpClient {
+    request(data: HttpRequest): Promise<HttpResponse>;
+}

package/lib/infra/http/axios-http-client.js

@@ -0,0 +1,39 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosHttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class AxiosHttpClient {
+    request(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let axiosResponse;
+            try {
+                axiosResponse = yield axios_1.default.request({
+                    url: data.url,
+                    method: data.method,
+                    data: data.body,
+                    headers: data.headers
+                });
+            }
+            catch (error) {
+                axiosResponse = error.response;
+            }
+            return {
+                statusCode: axiosResponse.status,
+                body: axiosResponse.data
+            };
+        });
+    }
+}
+exports.AxiosHttpClient = AxiosHttpClient;

package/lib/validation/builder.d.ts

@@ -0,0 +1,43 @@
+import { Validator } from './protocols';
+/**
+ * Fluent assembly of the rules that apply to one field.
+ *
+ * `ValidationBuilder.of({ value, fieldName }).required().interpolated().build()`
+ * reads as the requirement itself, and keeps the field name stated once instead
+ * of repeated into every rule.
+ */
+export declare class ValidationBuilder {
+    private readonly value;
+    private readonly fieldName;
+    private readonly validators;
+    private skipWhenEmpty;
+    private constructor();
+    static of({ value, fieldName }: {
+        value: any;
+        fieldName: string;
+    }): ValidationBuilder;
+    /**
+     * An absent or blank value passes every rule; the rules only apply to a value
+     * that is actually there.
+     */
+    optional(): ValidationBuilder;
+    /** The value must be a non-empty, non-whitespace string. */
+    required(): ValidationBuilder;
+    /** The value must be a finite number greater than zero. */
+    positiveNumber(): ValidationBuilder;
+    /** The survey platform must have interpolated the value. */
+    interpolated(): ValidationBuilder;
+    /** When present, the value must parse to a JSON object. */
+    jsonObject(): ValidationBuilder;
+    /** The value must be shaped like an ISO 3166-1 alpha-2 country code. */
+    countryCode(): ValidationBuilder;
+    /** The value must be shaped like an ISO 639-1 language code. */
+    languageCode(): ValidationBuilder;
+    /** The value must name a function on `window`. */
+    globalFunction(): ValidationBuilder;
+    /** The value must be a usable schedule record. */
+    scheduleRecord(): ValidationBuilder;
+    build(): Validator[];
+    /** Assembles the rules and runs them, reporting the first failure. */
+    validate(): Error | undefined;
+}