@camstack/types 1.2.453 → 1.2.455

package/dist/remote/remote-config.d.ts

@@ -3,7 +3,7 @@
  * the layout payload of the `remote` template kind. Pure data: no runtime, no
  * node dependency, so the admin UI imports the same schemas the server checks.
  *
- * A binding is the SAME shape an Action step has (`AutomationCapStepSchema`: a
+ * A binding is the SAME shape an Action step has (`AutomationCapStepBaseSchema`: a
  * cap method called on a device with arguments), narrowed to ONE device: an IR
  * code is `ir-transmitter.send` on the transmitter, a smart TV is a `switch` or a
  * vendor cap — the remote does not know which. How many times a command is sent
@@ -11,22 +11,22 @@
  */
 import { z } from 'zod';
 export declare const RemoteBindingActionSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
     kind: z.ZodLiteral<"cap">;
     cap: z.ZodString;
     method: z.ZodString;
     args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     argUnits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    deviceId: z.ZodNumber;
 }, z.core.$strip>;
 export type RemoteBindingAction = z.infer<typeof RemoteBindingActionSchema>;
 export declare const RemoteBindingSchema: z.ZodObject<{
     action: z.ZodObject<{
+        deviceId: z.ZodNumber;
         kind: z.ZodLiteral<"cap">;
         cap: z.ZodString;
         method: z.ZodString;
         args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         argUnits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        deviceId: z.ZodNumber;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type RemoteBinding = z.infer<typeof RemoteBindingSchema>;
@@ -48,12 +48,12 @@ export declare const RemoteConfigSchema: z.ZodObject<{
     defaultTransmitterId: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
     bindings: z.ZodRecord<z.ZodString, z.ZodObject<{
         action: z.ZodObject<{
+            deviceId: z.ZodNumber;
             kind: z.ZodLiteral<"cap">;
             cap: z.ZodString;
             method: z.ZodString;
             args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             argUnits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            deviceId: z.ZodNumber;
         }, z.core.$strip>;
     }, z.core.$strip>>;
     customButtons: z.ZodArray<z.ZodObject<{
@@ -176,6 +176,11 @@ export declare const RemoteLayoutGroupSchema: z.ZodObject<{
     rowSpan: z.ZodNumber;
     colSpan: z.ZodNumber;
     title: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodEnum<{
+        compact: "compact";
+        normal: "normal";
+    }>>;
+    hideTitle: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type RemoteLayoutGroup = z.infer<typeof RemoteLayoutGroupSchema>;
 export interface LayoutRect {
@@ -232,6 +237,11 @@ export declare const RemoteLayoutPayloadSchema: z.ZodObject<{
         rowSpan: z.ZodNumber;
         colSpan: z.ZodNumber;
         title: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodEnum<{
+            compact: "compact";
+            normal: "normal";
+        }>>;
+        hideTitle: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type RemoteLayoutPayload = z.infer<typeof RemoteLayoutPayloadSchema>;

package/dist/time/index.d.ts

@@ -0,0 +1,2 @@
+export * from './solar.js';
+export * from './time-spec.js';

package/dist/time/solar.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Where the sun is, from a latitude and a longitude — the one solar
+ * calculation in the repo. Compact NOAA sunrise equation (accurate to about a
+ * minute away from the poles), so no astronomy dependency is needed.
+ *
+ * Two consumers read it: the scene-condition resolver (day / night / dawn /
+ * dusk of a camera) and a schedule's sun time (`time-spec.ts`).
+ */
+/** The sun's upper limb on the horizon, refraction included: sunrise and sunset. */
+export declare const SUNRISE_ALTITUDE_DEG = -0.833;
+/** The sun's centre 6 degrees below the horizon: civil dawn and civil dusk. */
+export declare const CIVIL_TWILIGHT_ALTITUDE_DEG = -6;
+/**
+ * The two moments, in UTC epoch ms, at which the sun crosses an altitude on one
+ * day: going up (`rise`) and going down (`set`).
+ */
+export interface SunCrossings {
+    readonly rise: number;
+    readonly set: number;
+}
+/**
+ * When the sun crosses `altitudeDeg` on the day `date` falls in at this place.
+ * Pass an instant near local midday of the civil day you mean: the day is
+ * chosen from the instant, and midday is the one that never straddles two.
+ *
+ * `null` when the sun never crosses that altitude that day (polar day or polar
+ * night, or — for a twilight altitude — a summer night that never gets dark
+ * enough). The caller decides what that means; nothing here guesses.
+ */
+export declare function sunCrossings(lat: number, lng: number, date: Date, altitudeDeg: number): SunCrossings | null;
+/**
+ * Sunrise and sunset (UTC epoch ms) for a place and date; `null` for the polar
+ * cases (the sun never rises or sets that day).
+ */
+export declare function sunTimes(lat: number, lng: number, date: Date): SunCrossings | null;
+/** Civil dawn and dusk (UTC epoch ms); `null` when the sun never gets that low or that high. */
+export declare function twilightTimes(lat: number, lng: number, date: Date): SunCrossings | null;

package/dist/time/time-spec.d.ts

@@ -0,0 +1,117 @@
+/**
+ * WHEN something happens, as data (D983) — the one time vocabulary of the
+ * scheduler and of an automation's schedule leaf. Three shapes, no cron:
+ *
+ *  - `clock` — a wall-clock time every day (`07:30`), read in the site's zone;
+ *  - `sun`   — a sun event (`sunrise`, `sunset`, `dawn`, `dusk`) plus or minus
+ *    up to twelve hours, from the site's coordinates;
+ *  - `date`  — one local date and time (`2026-12-24T18:00`), once.
+ *
+ * A site is a place and its IANA zone ({@link TimeSite}). Every function here
+ * is pure: the zone arithmetic uses `Intl`, no date library.
+ *
+ * Wall-clock honesty across a DST change: a local time that does not exist
+ * (02:30 on the spring-forward day) happens at the first minute that does
+ * (03:00); one that happens twice (02:30 on the fall-back day) happens at its
+ * FIRST occurrence.
+ */
+import { z } from 'zod';
+export declare const SunEventSchema: z.ZodEnum<{
+    dawn: "dawn";
+    dusk: "dusk";
+    sunrise: "sunrise";
+    sunset: "sunset";
+}>;
+export type SunEvent = z.infer<typeof SunEventSchema>;
+export declare const TimeSpecSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"clock">;
+    hh: z.ZodNumber;
+    mm: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"sun">;
+    event: z.ZodEnum<{
+        dawn: "dawn";
+        dusk: "dusk";
+        sunrise: "sunrise";
+        sunset: "sunset";
+    }>;
+    offsetMin: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"date">;
+    local: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type TimeSpec = z.infer<typeof TimeSpecSchema>;
+/** A day of the week as a schedule names it. */
+export declare const WeekdayKeySchema: z.ZodEnum<{
+    fri: "fri";
+    mon: "mon";
+    sat: "sat";
+    sun: "sun";
+    thu: "thu";
+    tue: "tue";
+    wed: "wed";
+}>;
+export type WeekdayKey = z.infer<typeof WeekdayKeySchema>;
+/** Where a spec is read: coordinates for the sun, an IANA zone for the wall clock. */
+export interface TimeSite {
+    readonly lat: number;
+    readonly lon: number;
+    readonly timeZone: string;
+}
+/**
+ * A moment as epoch ms, or `null` — "nothing happens". `null` means one of two
+ * things and only these: the sun never crosses the event's altitude that day
+ * (polar day or night), or a `date` spec asked about a day that is not its own.
+ */
+export type Occurrence = number | null;
+/** Is `timeZone` a zone this runtime knows? */
+export declare function isKnownTimeZone(timeZone: string): boolean;
+/** `YYYY-MM-DD` of an instant, read in the zone. */
+export declare function localDateOf(epochMs: number, timeZone: string): string;
+/** The weekday of a `YYYY-MM-DD` civil date (zone-independent). */
+export declare function weekdayOfLocalDate(localDate: string): WeekdayKey;
+/**
+ * The moment `spec` happens on the site-local date `localDate` (`YYYY-MM-DD`).
+ * See {@link Occurrence} for what `null` means.
+ */
+export declare function occurrenceOn(spec: TimeSpec, localDate: string, site: TimeSite): Occurrence;
+/** How far ahead {@link nextOccurrence} looks before giving up: a polar winter fits. */
+export declare const NEXT_OCCURRENCE_HORIZON_DAYS = 400;
+export interface NextOccurrenceOptions {
+    /** Only on these weekdays, judged on the site-local date the spec belongs to. */
+    readonly days?: readonly WeekdayKey[];
+}
+/**
+ * The first moment strictly after `afterMs` at which `spec` happens, or `null`
+ * when none does within {@link NEXT_OCCURRENCE_HORIZON_DAYS} (a `date` spec in
+ * the past, a sun event that never happens, an empty `days` list).
+ */
+export declare function nextOccurrence(spec: TimeSpec, afterMs: number, site: TimeSite, options?: NextOccurrenceOptions): Occurrence;
+/** What `system.getSiteLocation` answers, as far as a spec needs it. */
+export interface SiteReading {
+    readonly location: {
+        readonly latitude: number;
+        readonly longitude: number;
+    } | null;
+    readonly timeZone: string;
+}
+export type TimeSpecRefusal = 'sun-needs-site-location' | 'unknown-time-zone';
+export type TimeSpecValidation = {
+    readonly ok: true;
+    readonly site: TimeSite | null;
+} | {
+    readonly ok: false;
+    readonly reason: TimeSpecRefusal;
+    readonly message: string;
+};
+/**
+ * Can `spec` be scheduled at this site? A sun spec without a location is
+ * REFUSED with its reason — never read as a guessed sunrise. A clock or date
+ * spec needs only a zone, and `site` is `null` in that case when there is no
+ * location (it is not needed to place them; use {@link siteFor} to read them).
+ */
+export declare function validateTimeSpecForSite(spec: TimeSpec, reading: SiteReading): TimeSpecValidation;
+/** The site, when it has a location; a clock spec on a site without one uses {@link zoneOnlySite}. */
+export declare function siteFor(reading: SiteReading): TimeSite | null;
+/** A site that can place a clock or date spec but no sun event (coordinates are unused by those). */
+export declare function zoneOnlySite(timeZone: string): TimeSite;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.453",
+  "version": "1.2.455",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",