@switchbot/openapi-cli 2.7.2 → 3.1.0

package/dist/rules/matcher.js

@@ -0,0 +1,230 @@
+/**
+ * Pure matching helpers for the rules engine.
+ *
+ * v0.2 scope:
+ *   - `matchesMqttTrigger`   — event + optional deviceId filter
+ *   - `classifyMqttPayload`  — heuristic that turns a raw shadow
+ *                              payload into a canonical event name
+ *   - `evaluateConditions`   — time_between (sync) + device_state
+ *                              (async, requires caller-supplied fetcher)
+ *
+ * All matching stays pure: `evaluateConditions` does not touch the
+ * filesystem, network, or globals. Callers inject a `fetchStatus`
+ * function; the engine's caller-provided fetcher dedupes per-tick so
+ * multiple rules querying the same device share one round trip.
+ */
+import { isDeviceState, isTimeBetween, isAllCondition, isAnyCondition, isNotCondition, } from './types.js';
+import { isWithinTuple } from './quiet-hours.js';
+/**
+ * Mapped states from SwitchBot MQTT shadow payloads. Each entry lists
+ * the canonical event name plus the payload-field + value that produces
+ * it. Keep this table tiny in the PoC — we widen it as users ask for
+ * more event names.
+ */
+const EVENT_CLASSIFIERS = [
+    { field: 'detectionState', value: 'DETECTED', event: 'motion.detected' },
+    { field: 'detectionState', value: 'NOT_DETECTED', event: 'motion.cleared' },
+    { field: 'openState', value: 'OPEN', event: 'contact.opened' },
+    { field: 'openState', value: 'CLOSE', event: 'contact.closed' },
+    { field: 'openState', value: 'TIMEOUT_NOT_CLOSED', event: 'contact.opened' },
+];
+/** Extract `deviceMac` + a classified event from a shadow message. */
+export function classifyMqttPayload(payload) {
+    const p = payload;
+    const ctx = (p?.context ?? {});
+    const deviceId = typeof ctx.deviceMac === 'string' ? ctx.deviceMac : undefined;
+    for (const c of EVENT_CLASSIFIERS) {
+        const raw = ctx[c.field];
+        if (typeof raw !== 'string')
+            continue;
+        if (c.value instanceof RegExp ? c.value.test(raw) : raw === c.value) {
+            return { event: c.event, deviceId };
+        }
+    }
+    return { event: 'device.shadow', deviceId };
+}
+/**
+ * Compare an MQTT trigger against an `EngineEvent`. We accept a trigger
+ * when the event name matches AND the optional `device` filter resolves
+ * to the event's deviceId (callers pre-resolve aliases → deviceIds so
+ * the matcher stays pure).
+ */
+export function matchesMqttTrigger(trigger, event, resolvedTriggerDeviceId) {
+    if (event.source !== 'mqtt')
+        return false;
+    if (trigger.event !== event.event && trigger.event !== 'device.shadow')
+        return false;
+    if (resolvedTriggerDeviceId && event.deviceId && resolvedTriggerDeviceId !== event.deviceId) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Evaluate all conditions; AND-joined at the top level. Composite nodes
+ * (all/any/not) are evaluated recursively. Unsupported conditions short-
+ * circuit to "not matched" and surface in `unsupported` so the engine
+ * can warn loudly rather than silently drop fires. device_state
+ * conditions need `ctx.fetchStatus` — without it they count as
+ * unsupported (e.g. lint / dry list paths).
+ */
+export async function evaluateConditions(conditions, now, ctx = {}) {
+    const result = { matched: true, failures: [], unsupported: [] };
+    if (!conditions || conditions.length === 0)
+        return result;
+    for (const c of conditions) {
+        const sub = await evaluateSingle(c, now, ctx);
+        if (!sub.matched) {
+            result.matched = false;
+            result.failures.push(...sub.failures);
+        }
+        result.unsupported.push(...sub.unsupported);
+        if (!sub.matched && result.unsupported.length > 0) {
+            // Propagate unsupported from inner composite even if outer still matched
+        }
+    }
+    return result;
+}
+async function evaluateSingle(c, now, ctx) {
+    const ok = { matched: true, failures: [], unsupported: [] };
+    const fail = (msg) => ({ matched: false, failures: [msg], unsupported: [] });
+    if (isAllCondition(c)) {
+        const result = { matched: true, failures: [], unsupported: [] };
+        for (const sub of c.all) {
+            const r = await evaluateSingle(sub, now, ctx);
+            if (!r.matched) {
+                result.matched = false;
+                result.failures.push(...r.failures);
+            }
+            result.unsupported.push(...r.unsupported);
+        }
+        return result;
+    }
+    if (isAnyCondition(c)) {
+        const result = { matched: false, failures: [], unsupported: [] };
+        for (const sub of c.any) {
+            const r = await evaluateSingle(sub, now, ctx);
+            result.unsupported.push(...r.unsupported);
+            if (r.matched) {
+                result.matched = true;
+                result.failures = [];
+                return result;
+            }
+            result.failures.push(...r.failures);
+        }
+        return result;
+    }
+    if (isNotCondition(c)) {
+        const r = await evaluateSingle(c.not, now, ctx);
+        if (r.unsupported.length > 0)
+            return { matched: false, failures: [], unsupported: r.unsupported };
+        return r.matched ? fail('not: inner condition matched (negated)') : ok;
+    }
+    if (isTimeBetween(c)) {
+        return isWithinTuple(c.time_between, now)
+            ? ok
+            : fail(`time_between ${c.time_between[0]}-${c.time_between[1]} did not include ${now.toTimeString().slice(0, 5)}`);
+    }
+    if (isDeviceState(c)) {
+        if (!ctx.fetchStatus) {
+            return {
+                matched: false,
+                failures: [],
+                unsupported: [{ keyword: 'device_state', hint: 'device_state evaluation requires a live status fetcher; this call site did not provide one.' }],
+            };
+        }
+        const resolved = resolveDeviceRef(c.device, ctx.aliases);
+        if (!resolved)
+            return fail(`device_state: could not resolve device "${c.device}" to an id (no matching alias).`);
+        try {
+            const status = await ctx.fetchStatus(resolved);
+            if (!compareField(status[c.field], c.op, c.value)) {
+                const actual = formatValue(status[c.field]);
+                const expected = formatValue(c.value);
+                return fail(`device_state ${c.device}.${c.field} ${c.op} ${expected} (actual: ${actual})`);
+            }
+            return ok;
+        }
+        catch (err) {
+            return fail(`device_state ${c.device}.${c.field}: fetch failed — ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return {
+        matched: false,
+        failures: [],
+        unsupported: [{ keyword: 'unknown', hint: `Unrecognised condition shape: ${JSON.stringify(c).slice(0, 120)}` }],
+    };
+}
+function resolveDeviceRef(ref, aliases) {
+    if (!ref)
+        return null;
+    if (aliases && ref in aliases)
+        return aliases[ref];
+    // Raw deviceId (MAC / SwitchBot id) — accept as-is.
+    return ref;
+}
+function compareField(actual, op, expected) {
+    // Equality operators run on the raw values so booleans, numbers, and
+    // strings all work naturally. Ordering operators coerce to numbers —
+    // JSON statuses often arrive as strings like "22.5" so coercion is
+    // what people mean when they write `battery >= 20`.
+    switch (op) {
+        case '==':
+            return looseEqual(actual, expected);
+        case '!=':
+            return !looseEqual(actual, expected);
+        case '<':
+        case '>':
+        case '<=':
+        case '>=': {
+            const a = toNumber(actual);
+            const b = toNumber(expected);
+            if (a === null || b === null)
+                return false;
+            if (op === '<')
+                return a < b;
+            if (op === '>')
+                return a > b;
+            if (op === '<=')
+                return a <= b;
+            return a >= b;
+        }
+        default:
+            return false;
+    }
+}
+function looseEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === undefined || b === undefined || a === null || b === null)
+        return false;
+    // Strings from shadow payloads are case-sensitive for device states
+    // (e.g. "on" / "off") — policy authors can match explicitly. Numbers
+    // coerce through `Number()` so `"22" == 22` holds.
+    if (typeof a === 'number' || typeof b === 'number') {
+        const na = toNumber(a);
+        const nb = toNumber(b);
+        return na !== null && nb !== null && na === nb;
+    }
+    return String(a) === String(b);
+}
+function toNumber(v) {
+    if (typeof v === 'number')
+        return Number.isFinite(v) ? v : null;
+    if (typeof v === 'string') {
+        const trimmed = v.trim();
+        if (!trimmed)
+            return null;
+        const n = Number(trimmed);
+        return Number.isFinite(n) ? n : null;
+    }
+    if (typeof v === 'boolean')
+        return v ? 1 : 0;
+    return null;
+}
+function formatValue(v) {
+    if (v === undefined)
+        return 'undefined';
+    if (typeof v === 'string')
+        return JSON.stringify(v);
+    return String(v);
+}

package/dist/rules/pid-file.js

@@ -0,0 +1,95 @@
+/**
+ * Cross-platform supervisor glue for `switchbot rules run`.
+ *
+ * The running engine registers a pid file and a reload sentinel under
+ * `~/.switchbot/`; the `switchbot rules reload` subcommand reads them
+ * to signal the live process:
+ *
+ *   - Unix (SIGHUP supported): `process.kill(pid, 'SIGHUP')`.
+ *   - Windows (no SIGHUP): write `~/.switchbot/rules.reload`. The engine
+ *     polls this path and consumes it, so the same `rules reload`
+ *     command works on every platform.
+ *
+ * The files are tiny (<100 bytes) and created with 0o600; cleanup is
+ * best-effort on exit so a crash leaves at most a stale pid the user
+ * can overwrite with a fresh `rules run`.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const DEFAULT_DIR = path.join(os.homedir(), '.switchbot');
+export function getDefaultPidFilePaths() {
+    return {
+        dir: DEFAULT_DIR,
+        pidFile: path.join(DEFAULT_DIR, 'rules.pid'),
+        reloadFile: path.join(DEFAULT_DIR, 'rules.reload'),
+    };
+}
+/** Write the current process pid. Creates parent dir with 0700 if needed. */
+export function writePidFile(pidFile, pid = process.pid) {
+    const dir = path.dirname(pidFile);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(pidFile, `${pid}\n`, { mode: 0o600 });
+}
+/** Return the pid persisted in the file, or null if absent / unparseable. */
+export function readPidFile(pidFile) {
+    try {
+        const raw = fs.readFileSync(pidFile, 'utf-8').trim();
+        const n = Number(raw);
+        return Number.isInteger(n) && n > 0 ? n : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove the pid file only when it still refers to the current process.
+ * A stale file from an earlier run is left alone so we don't accidentally
+ * clobber a new supervisor that already won the race.
+ */
+export function clearPidFile(pidFile, pid = process.pid) {
+    try {
+        const existing = readPidFile(pidFile);
+        if (existing === pid)
+            fs.unlinkSync(pidFile);
+    }
+    catch {
+        // best effort
+    }
+}
+export function writeReloadSentinel(reloadFile) {
+    const dir = path.dirname(reloadFile);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(reloadFile, `${Date.now()}\n`, { mode: 0o600 });
+}
+export function consumeReloadSentinel(reloadFile) {
+    try {
+        if (!fs.existsSync(reloadFile))
+            return false;
+        fs.unlinkSync(reloadFile);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Detect whether SIGHUP is usable on the current platform. */
+export function sighupSupported() {
+    return process.platform !== 'win32';
+}
+/**
+ * Check whether a pid is alive — used by `rules reload` to avoid
+ * signalling dead pids, which would otherwise leave the user wondering
+ * why nothing happened. Node's `process.kill(pid, 0)` throws `ESRCH`
+ * for dead pids and `EPERM` for pids we cannot signal (still alive).
+ */
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        return code === 'EPERM';
+    }
+}

package/dist/rules/quiet-hours.js

@@ -0,0 +1,45 @@
+/**
+ * Time-window helpers shared by `time_between` conditions and (later)
+ * the top-level `quiet_hours` block. Both evaluate a local-clock HH:MM
+ * range that may cross midnight.
+ */
+const HHMM = /^([01]\d|2[0-3]):[0-5]\d$/;
+function toMinutes(hhmm) {
+    if (!HHMM.test(hhmm)) {
+        throw new Error(`Invalid HH:MM value: "${hhmm}"`);
+    }
+    const [h, m] = hhmm.split(':').map(Number);
+    return h * 60 + m;
+}
+function minutesOf(d) {
+    return d.getHours() * 60 + d.getMinutes();
+}
+/**
+ * `true` when `now` falls inside the window. If `start > end` the window
+ * is interpreted as overnight (e.g. 22:00 → 07:00 crosses midnight).
+ *
+ * Boundary semantics: start is inclusive, end is exclusive. A window of
+ * 09:00 → 09:00 therefore matches nothing — callers who want "always"
+ * should omit the condition entirely rather than fake it with equal
+ * times.
+ */
+export function isWithin(window, now) {
+    const s = toMinutes(window.start);
+    const e = toMinutes(window.end);
+    const n = minutesOf(now);
+    if (s === e)
+        return false;
+    if (s < e)
+        return n >= s && n < e;
+    return n >= s || n < e;
+}
+/** Convenience wrapper that accepts the schema's tuple shape. */
+export function isWithinTuple(range, now) {
+    return isWithin({ start: range[0], end: range[1] }, now);
+}
+/** Top-level quiet_hours block helper — same math, schema shape differs. */
+export function isInQuietHours(qh, now) {
+    if (!qh?.start || !qh.end)
+        return false;
+    return isWithin({ start: qh.start, end: qh.end }, now);
+}

package/dist/rules/suggest.js

@@ -0,0 +1,95 @@
+import { stringify as yamlStringify } from 'yaml';
+import { COMMAND_KEYWORDS } from '../lib/command-keywords.js';
+const TRIGGER_KEYWORDS = [
+    { pattern: /\bmotion\b|\bdetect/i, trigger: 'mqtt', event: 'motion.detected' },
+    { pattern: /\bdoor\b|\bcontact\b|\bopen.*sensor/i, trigger: 'mqtt', event: 'contact.opened' },
+    { pattern: /\bbutton\b|\bpress/i, trigger: 'mqtt', event: 'button.pressed' },
+    { pattern: /\bwebhook\b|\bhttp\b|\bifttt\b/i, trigger: 'webhook' },
+    { pattern: /\bevery\b|\bdaily\b|\bmorning\b|\bnight\b|\bevening\b|\b\d{1,2}\s*[ap]m\b/i, trigger: 'cron' },
+];
+function inferTrigger(intent) {
+    for (const t of TRIGGER_KEYWORDS) {
+        if (t.pattern.test(intent))
+            return { trigger: t.trigger, event: t.event };
+    }
+    return { trigger: 'mqtt', event: 'device.shadow' };
+}
+function inferSchedule(intent, warnings) {
+    const amMatch = /\b(\d{1,2})\s*am\b/i.exec(intent);
+    if (amMatch)
+        return `0 ${parseInt(amMatch[1], 10)} * * *`;
+    const pmMatch = /\b(\d{1,2})\s*pm\b/i.exec(intent);
+    if (pmMatch)
+        return `0 ${parseInt(pmMatch[1], 10) + 12} * * *`;
+    if (/\bevery\s*hour/i.test(intent))
+        return '0 * * * *';
+    if (/\bnight\b|\bevening\b/i.test(intent))
+        return '0 22 * * *';
+    if (/\bmorning\b/i.test(intent))
+        return '0 8 * * *';
+    warnings.push(`Could not infer cron schedule from intent "${intent}" — defaulted to "0 8 * * *". Edit the generated rule to set the correct schedule.`);
+    return '0 8 * * *';
+}
+function inferCommand(intent, warnings) {
+    for (const k of COMMAND_KEYWORDS) {
+        if (k.pattern.test(intent))
+            return k.command;
+    }
+    warnings.push(`Could not infer command from intent "${intent}" — defaulted to "turnOn". Edit the generated rule to set the correct command.`);
+    return 'turnOn';
+}
+export function suggestRule(opts) {
+    const warnings = [];
+    // Resolve trigger
+    let triggerSource = opts.trigger;
+    let inferredEvent;
+    if (!triggerSource) {
+        const inferred = inferTrigger(opts.intent);
+        triggerSource = inferred.trigger;
+        inferredEvent = inferred.event;
+        if (inferredEvent === 'device.shadow') {
+            warnings.push(`Could not infer trigger type from intent "${opts.intent}" — defaulted to mqtt/device.shadow. Set --trigger and --event explicitly.`);
+        }
+    }
+    // Build the when block
+    let when;
+    if (triggerSource === 'mqtt') {
+        const event = opts.event ?? inferredEvent ?? 'device.shadow';
+        const mqttTrigger = { source: 'mqtt', event };
+        if (opts.devices && opts.devices.length > 0) {
+            const sensorDevice = opts.devices[0];
+            mqttTrigger.device = sensorDevice.name ?? sensorDevice.id;
+        }
+        when = mqttTrigger;
+    }
+    else if (triggerSource === 'cron') {
+        const schedule = opts.schedule ?? inferSchedule(opts.intent, warnings);
+        const cronTrigger = { source: 'cron', schedule };
+        if (opts.days && opts.days.length > 0)
+            cronTrigger.days = opts.days;
+        when = cronTrigger;
+    }
+    else {
+        when = { source: 'webhook', path: opts.webhookPath ?? '/action' };
+    }
+    // Build then[] — one action per device (skip the sensor device for mqtt)
+    const command = inferCommand(opts.intent, warnings);
+    const actionDevices = triggerSource === 'mqtt' && opts.devices && opts.devices.length > 1
+        ? opts.devices.slice(1)
+        : (opts.devices ?? []);
+    const then = actionDevices.length > 0
+        ? actionDevices.map((d) => ({
+            command: `devices command <id> ${command}`,
+            device: d.name ?? d.id,
+        }))
+        : [{ command: `devices command <id> ${command}` }];
+    const rule = {
+        name: opts.intent,
+        when,
+        then,
+        dry_run: true,
+        ...(triggerSource === 'mqtt' ? { throttle: { max_per: '10m' } } : {}),
+    };
+    const ruleYaml = yamlStringify(rule, { lineWidth: 0 });
+    return { rule, ruleYaml, warnings };
+}

package/dist/rules/throttle.js

@@ -0,0 +1,116 @@
+/**
+ * Throttle gate — per-rule, optionally keyed by deviceId.
+ *
+ * Semantics:
+ *   - `max_per: "10m"` → a rule may fire at most once every 10 minutes
+ *     per (rule, deviceId) pair.
+ *   - `dedupe_window: "5s"` → suppress fires whose key already fired
+ *     within the window (collapses rapid sensor bursts into one action).
+ *   - Fires that would violate the window are **suppressed** (not
+ *     queued) and surface as `{ allowed: false, reason: 'throttled' }`.
+ *   - When a rule has no `throttle` block, `ThrottleGate.check` returns
+ *     `{ allowed: true }` immediately.
+ *
+ * The gate is in-memory only. Re-reads between processes (or after
+ * SIGHUP reload) start with a clean slate — a deliberate choice,
+ * because persisting throttle state would lock the engine into a
+ * schema that changes every time we add a trigger type.
+ */
+const DURATION_RE = /^(\d+)([smh])$/;
+export function parseMaxPerMs(expr) {
+    const m = DURATION_RE.exec(expr.trim());
+    if (!m)
+        throw new Error(`Invalid throttle.max_per: "${expr}"`);
+    const n = Number(m[1]);
+    const unit = m[2];
+    const unitMs = unit === 's' ? 1_000 : unit === 'm' ? 60_000 : 3_600_000;
+    return n * unitMs;
+}
+export class ThrottleGate {
+    lastFireAt = new Map();
+    /** Sliding-window fire-time log for count-based maxFiringsPerHour. */
+    fireTimes = new Map();
+    keyOf(ruleName, deviceId) {
+        return deviceId ? `${ruleName}::${deviceId}` : ruleName;
+    }
+    /**
+     * Does **not** record the fire. Call `record()` after the action
+     * actually runs so that dry-run / throttled paths don't bump the
+     * window.
+     */
+    check(ruleName, windowMs, now, deviceId, dedupeWindowMs) {
+        const key = this.keyOf(ruleName, deviceId);
+        const last = this.lastFireAt.get(key);
+        // dedupe_window check: suppress if last fire was within this (typically smaller) window
+        if (dedupeWindowMs !== null && dedupeWindowMs !== undefined && dedupeWindowMs > 0) {
+            if (last !== undefined) {
+                const dedupeEnd = last + dedupeWindowMs;
+                if (now < dedupeEnd) {
+                    return { allowed: false, lastFiredAt: last, nextAllowedAt: dedupeEnd, dedupedBy: 'dedupe_window' };
+                }
+            }
+        }
+        // max_per / cooldown check
+        if (windowMs === null || windowMs <= 0)
+            return { allowed: true, lastFiredAt: last };
+        if (last === undefined)
+            return { allowed: true };
+        const earliest = last + windowMs;
+        if (now >= earliest)
+            return { allowed: true, lastFiredAt: last };
+        return { allowed: false, lastFiredAt: last, nextAllowedAt: earliest, dedupedBy: windowMs > 0 ? 'max_per' : undefined };
+    }
+    record(ruleName, now, deviceId) {
+        this.lastFireAt.set(this.keyOf(ruleName, deviceId), now);
+    }
+    /** Count-based check: has the rule fired >= maxCount times in the last windowMs? */
+    checkMaxFirings(ruleName, maxCount, windowMs, now, deviceId) {
+        const key = this.keyOf(ruleName, deviceId);
+        const times = (this.fireTimes.get(key) ?? []).filter((t) => now - t < windowMs);
+        this.fireTimes.set(key, times);
+        return { allowed: times.length < maxCount, count: times.length, max: maxCount };
+    }
+    /** Record a count-based fire (call alongside record()). */
+    recordFire(ruleName, now, deviceId) {
+        const key = this.keyOf(ruleName, deviceId);
+        const times = this.fireTimes.get(key) ?? [];
+        times.push(now);
+        this.fireTimes.set(key, times);
+    }
+    /** Drop everything — used by engine.reload when a rule is removed. */
+    forget(ruleName) {
+        const prefix = `${ruleName}::`;
+        for (const k of this.lastFireAt.keys()) {
+            if (k === ruleName || k.startsWith(prefix))
+                this.lastFireAt.delete(k);
+        }
+        for (const k of this.fireTimes.keys()) {
+            if (k === ruleName || k.startsWith(prefix))
+                this.fireTimes.delete(k);
+        }
+    }
+    /**
+     * Drop every window whose rule name isn't in the given set — used by
+     * `engine.reload` after a policy swap. Entries for names that survive
+     * the reload are preserved so unchanged rules don't get a free
+     * one-fire amnesty.
+     */
+    retainOnly(ruleNames) {
+        for (const k of this.lastFireAt.keys()) {
+            const sep = k.indexOf('::');
+            const ruleName = sep === -1 ? k : k.slice(0, sep);
+            if (!ruleNames.has(ruleName))
+                this.lastFireAt.delete(k);
+        }
+        for (const k of this.fireTimes.keys()) {
+            const sep = k.indexOf('::');
+            const ruleName = sep === -1 ? k : k.slice(0, sep);
+            if (!ruleNames.has(ruleName))
+                this.fireTimes.delete(k);
+        }
+    }
+    /** Test helper — exposes the underlying size. */
+    size() {
+        return this.lastFireAt.size;
+    }
+}

package/dist/rules/types.js

@@ -0,0 +1,34 @@
+/**
+ * Runtime TypeScript shapes for policy v0.2 rule objects.
+ *
+ * These are hand-mirrored from `src/policy/schema/v0.2.json` — the ajv
+ * validator is the source of truth for what a file may contain, this
+ * file is the source of truth for what the engine expects after load.
+ * When you edit one, edit the other in the same commit.
+ */
+/** Guards used outside this file. */
+export function isMqttTrigger(t) {
+    return t.source === 'mqtt';
+}
+export function isCronTrigger(t) {
+    return t.source === 'cron';
+}
+export function isWebhookTrigger(t) {
+    return t.source === 'webhook';
+}
+export function isTimeBetween(c) {
+    return Array.isArray(c.time_between);
+}
+export function isDeviceState(c) {
+    const d = c;
+    return typeof d.device === 'string' && typeof d.field === 'string' && typeof d.op === 'string';
+}
+export function isAllCondition(c) {
+    return Array.isArray(c.all);
+}
+export function isAnyCondition(c) {
+    return Array.isArray(c.any);
+}
+export function isNotCondition(c) {
+    return c.not !== undefined && !Array.isArray(c.not);
+}