@snaptrude/plugin-core 0.0.0-dev-20260708130115 → 0.0.0-dev-20260827135706

package/dist/api/analysis/sunlightHours.d.ts

@@ -0,0 +1,208 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../types";
+/**
+ * Analysis sunlightHours — the direct-sunlight-hours heatmap study.
+ *
+ * Computes, for every space surface (Room or Department Mass — generic
+ * Masses are not enough), how many hours of direct sunlight
+ * it receives over a date range, and renders the result as a heatmap on the
+ * scene. The computation is an **asynchronous backend job**:
+ *
+ * 1. {@linkcode PluginAnalysisSunlightHoursApi.compute} starts the job and
+ *    returns immediately.
+ * 2. Poll {@linkcode PluginAnalysisSunlightHoursApi.get} until `status` is
+ *    `"active"` (heatmap rendered) — a run typically takes minutes. There is
+ *    no completion event; polling is the pattern.
+ * 3. {@linkcode PluginAnalysisSunlightHoursApi.cancel} aborts an in-flight
+ *    run; {@linkcode PluginAnalysisSunlightHoursApi.reset} clears a rendered
+ *    heatmap.
+ *
+ * Heatmaps are invalidated by scene-mutating edits — re-run the study after
+ * changing the model. Dates cross as ISO 8601 date strings (`"YYYY-MM-DD"`).
+ *
+ * Accessed via `snaptrude.analysis.sunlightHours`.
+ */
+export declare abstract class PluginAnalysisSunlightHoursApi {
+    constructor();
+    /**
+     * Start a direct-sunlight-hours run for a date range.
+     *
+     * Starts the backend job and **returns immediately** — it does not wait
+     * for the heatmap. Poll {@linkcode PluginAnalysisSunlightHoursApi.get}
+     * until `status` is `"active"`. Starting a new run while one is in flight
+     * replaces it. Shadows and the heatmap analyses are mutually exclusive in
+     * the product: starting a run disables real-time shadows and resets/cancels
+     * any {@linkcode PluginAnalysisIlluminanceApi} (`analysis.illuminance`)
+     * study.
+     *
+     * @param startDate - Start of the study range, ISO date `"YYYY-MM-DD"`.
+     * @param endDate - End of the study range, ISO date `"YYYY-MM-DD"` (on or
+     *   after `startDate`).
+     * @returns A {@linkcode PluginAnalysisComputeResult} — `{ success: true }`
+     *   when the job was started. The `{ success: false, error }` arm is
+     *   reserved — not yet emitted (start failures currently throw).
+     * @throws When the project has no geo-located site/terrain (no location to
+     *   compute sun exposure for — there is no fallback location).
+     * @throws When the scene has no space (Room or Department Mass) to analyse
+     *   or the editor is not in the 3D view.
+     * @throws When a date is not a parseable ISO date or the range is inverted.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Run a sunlight hours analysis for June
+     * @examplePrompt Compute direct sunlight hours between March and September
+     * @examplePrompt How much sun does my building get over the summer?
+     *
+     * # Example
+     * ```ts
+     * const { success } = await snaptrude.analysis.sunlightHours.compute(
+     *   "2026-06-01",
+     *   "2026-06-30",
+     * )
+     * // poll until the heatmap is rendered
+     * let job = await snaptrude.analysis.sunlightHours.get()
+     * while (job?.status === "running") {
+     *   await new Promise((r) => setTimeout(r, 5000))
+     *   job = await snaptrude.analysis.sunlightHours.get()
+     * }
+     * ```
+     */
+    abstract compute(startDate: string, endDate: string): PluginApiReturn<PluginAnalysisComputeResult>;
+    /**
+     * Get the state of the sunlight-hours study.
+     *
+     * The polling read for the async job started by
+     * {@linkcode PluginAnalysisSunlightHoursApi.compute}. `status` values:
+     *
+     * | Status | Meaning |
+     * |---|---|
+     * | `"running"` | A run is in flight — keep polling |
+     * | `"active"` | The heatmap is rendered on the scene |
+     * | `"inactive"` | A previous run exists but its heatmap is not showing |
+     *
+     * @returns A {@linkcode PluginAnalysisJobStateResult} with the `status` and
+     *   the run's ISO `startDate`/`endDate`, or `null` when no run result is
+     *   available (the study never ran, was cancelled, or the last run failed).
+     *
+     * @examplePrompt Is the sunlight analysis done?
+     * @examplePrompt Check the status of the sunlight hours run
+     * @examplePrompt What date range was the sunlight heatmap computed for?
+     *
+     * # Example
+     * ```ts
+     * const job = await snaptrude.analysis.sunlightHours.get()
+     * if (job?.status === "active") console.log(job.startDate, job.endDate)
+     * ```
+     */
+    abstract get(): PluginApiReturn<PluginAnalysisJobStateResult>;
+    /**
+     * Cancel the in-flight sunlight-hours run.
+     *
+     * Aborts the backend job. A no-op (returns `false`) when nothing is
+     * running.
+     *
+     * @returns `true` when a run was cancelled, `false` when nothing was
+     *   running.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Cancel the sunlight analysis
+     * @examplePrompt Stop the running sunlight hours computation
+     * @examplePrompt Abort the sun study
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.analysis.sunlightHours.cancel()
+     * ```
+     */
+    abstract cancel(): PluginApiReturn<boolean>;
+    /**
+     * Clear the sunlight-hours heatmap from the scene.
+     *
+     * Un-applies the rendered heatmap and restores the normal material view.
+     * A no-op (returns `false`) when no heatmap is showing. Does not cancel an
+     * in-flight run — use {@linkcode PluginAnalysisSunlightHoursApi.cancel}.
+     *
+     * @returns `true` when a heatmap was cleared, `false` when none was
+     *   showing.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Clear the sunlight heatmap
+     * @examplePrompt Remove the sun hours colours from the model
+     * @examplePrompt Reset the sunlight analysis view
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.analysis.sunlightHours.reset()
+     * ```
+     */
+    abstract reset(): PluginApiReturn<boolean>;
+}
+/**
+ * Result of starting an analysis job
+ * ({@linkcode PluginAnalysisSunlightHoursApi.compute} /
+ * {@linkcode PluginAnalysisIlluminanceApi.compute}).
+ *
+ * The `success: false` arm is **reserved — not yet emitted**: the current
+ * host always returns `{ success: true }` (start failures throw instead); a
+ * failure indicator may be added additively later.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `success` | `boolean` | `true` when the backend job was started |
+ * | `error` | `string \| undefined` | Failure reason when `success` is `false` (reserved — not yet emitted) |
+ */
+export declare const PluginAnalysisComputeResult: z.ZodObject<{
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PluginAnalysisComputeResult = z.infer<typeof PluginAnalysisComputeResult>;
+/**
+ * The status of an analysis heatmap job.
+ *
+ * | Value | Meaning |
+ * |---|---|
+ * | `"running"` | A run is in flight — keep polling |
+ * | `"active"` | The heatmap is rendered on the scene |
+ * | `"inactive"` | A previous run exists but its heatmap is not showing |
+ */
+export declare const PluginAnalysisJobStatus: z.ZodEnum<{
+    running: "running";
+    active: "active";
+    inactive: "inactive";
+}>;
+export type PluginAnalysisJobStatus = z.infer<typeof PluginAnalysisJobStatus>;
+/**
+ * The state of an analysis heatmap job.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `status` | {@linkcode PluginAnalysisJobStatus} | `"running"` \| `"active"` \| `"inactive"` |
+ * | `startDate` | `string` | ISO date (`"YYYY-MM-DD"`) the run was computed from |
+ * | `endDate` | `string` | ISO date (`"YYYY-MM-DD"`) the run was computed to |
+ */
+export declare const PluginAnalysisJobState: z.ZodObject<{
+    status: z.ZodEnum<{
+        running: "running";
+        active: "active";
+        inactive: "inactive";
+    }>;
+    startDate: z.ZodString;
+    endDate: z.ZodString;
+}, z.core.$strip>;
+export type PluginAnalysisJobState = z.infer<typeof PluginAnalysisJobState>;
+/**
+ * Result of {@linkcode PluginAnalysisSunlightHoursApi.get} /
+ * {@linkcode PluginAnalysisIlluminanceApi.get} — the job state, or `null`
+ * when no run result is available (the study never ran, was cancelled, or
+ * the last run failed).
+ */
+export declare const PluginAnalysisJobStateResult: z.ZodNullable<z.ZodObject<{
+    status: z.ZodEnum<{
+        running: "running";
+        active: "active";
+        inactive: "inactive";
+    }>;
+    startDate: z.ZodString;
+    endDate: z.ZodString;
+}, z.core.$strip>>;
+export type PluginAnalysisJobStateResult = z.infer<typeof PluginAnalysisJobStateResult>;
+//# sourceMappingURL=sunlightHours.d.ts.map

package/dist/api/analysis/sunlightHours.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sunlightHours.d.ts","sourceRoot":"","sources":["../../../src/api/analysis/sunlightHours.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8BAAsB,8BAA8B;;IAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;aACa,OAAO,CACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,eAAe,CAAC,2BAA2B,CAAC;IAE/C;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;aACa,GAAG,IAAI,eAAe,CAAC,4BAA4B,CAAC;IAEpE;;;;;;;;;;;;;;;;;;OAkBG;aACa,MAAM,IAAI,eAAe,CAAC,OAAO,CAAC;IAElD;;;;;;;;;;;;;;;;;;;OAmBG;aACa,KAAK,IAAI,eAAe,CAAC,OAAO,CAAC;CAClD;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAA;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,2BAA2B,CACnC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB;;;;EAIlC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;iBAIjC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;kBAAoC,CAAA;AAC7E,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,4BAA4B,CACpC,CAAA"}

package/dist/api/analysis/sunpath.d.ts

@@ -0,0 +1,80 @@
+import { PluginApiReturn } from "../../types";
+/**
+ * Analysis sunpath — the sun-path diagram overlay.
+ *
+ * The sun-path diagram draws the sun's annual/daily trajectory arcs over the
+ * scene for the project's geographic location, so daylight behaviour can be
+ * read directly off the model. Toggling it is an **undoable** action (it goes
+ * through the command stack, so `core.history.undo` reverts it).
+ *
+ * The overlay is computed for the project's geo-location. Enabling **throws**
+ * when the project has no geo-located site/terrain — there is no fallback
+ * location. Set the site location first (Import terrain / site context);
+ * read it via `program.site.getLocation`.
+ *
+ * Accessed via `snaptrude.analysis.sunpath`.
+ */
+export declare abstract class PluginAnalysisSunpathApi {
+    constructor();
+    /**
+     * Turn the sun-path diagram overlay ON.
+     *
+     * Undoable: the toggle is committed through the command stack. A no-op
+     * (returns `true`) when the overlay is already active.
+     *
+     * @returns `true` — the overlay is active after the call.
+     * @throws When the project has no geo-located site/terrain (no location to
+     *   compute the sun trajectory for).
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Show the sun path diagram
+     * @examplePrompt Turn on the sunpath overlay
+     * @examplePrompt Visualize the sun's trajectory over my building
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.analysis.sunpath.enable()
+     * const active = await snaptrude.analysis.sunpath.isActive() // true
+     * ```
+     */
+    abstract enable(): PluginApiReturn<boolean>;
+    /**
+     * Turn the sun-path diagram overlay OFF.
+     *
+     * Undoable: the toggle is committed through the command stack. A no-op
+     * (returns `false`) when the overlay is already off.
+     *
+     * @returns `false` — the overlay is inactive after the call.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Hide the sun path diagram
+     * @examplePrompt Turn off the sunpath overlay
+     * @examplePrompt Remove the sun trajectory arcs from the scene
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.analysis.sunpath.disable()
+     * ```
+     */
+    abstract disable(): PluginApiReturn<boolean>;
+    /**
+     * Whether the sun-path diagram overlay is currently active.
+     *
+     * A pure read — never mutates, never throws.
+     *
+     * @returns `true` when the overlay is showing.
+     *
+     * @examplePrompt Is the sun path diagram on?
+     * @examplePrompt Check whether the sunpath overlay is active
+     * @examplePrompt Am I looking at the sun trajectory right now?
+     *
+     * # Example
+     * ```ts
+     * if (!(await snaptrude.analysis.sunpath.isActive())) {
+     *   await snaptrude.analysis.sunpath.enable()
+     * }
+     * ```
+     */
+    abstract isActive(): PluginApiReturn<boolean>;
+}
+//# sourceMappingURL=sunpath.d.ts.map

package/dist/api/analysis/sunpath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sunpath.d.ts","sourceRoot":"","sources":["../../../src/api/analysis/sunpath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,wBAAwB;;IAG5C;;;;;;;;;;;;;;;;;;;;OAoBG;aACa,MAAM,IAAI,eAAe,CAAC,OAAO,CAAC;IAElD;;;;;;;;;;;;;;;;;OAiBG;aACa,OAAO,IAAI,eAAe,CAAC,OAAO,CAAC;IAEnD;;;;;;;;;;;;;;;;;OAiBG;aACa,QAAQ,IAAI,eAAe,CAAC,OAAO,CAAC;CACrD"}

package/dist/api/analysis/weather.d.ts

@@ -0,0 +1,193 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../types";
+/**
+ * Analysis weather — read the project site's typical-year weather series.
+ *
+ * Returns the hourly weather rows (temperature, humidity, wind, solar
+ * irradiance) of the EPW file the sustainability analyses compute against,
+ * resolved from the project's geo-located site. This is a **synchronous,
+ * paged read** of an already-resolved weather file — not a job: call
+ * {@linkcode PluginAnalysisWeatherApi.getSeries} for a date range, then follow
+ * `nextCursor` until it is `null`.
+ *
+ * The weather file is resolved by the **same** code path the daylight /
+ * sunlight-hours analyses use, so the `source.weatherFileId` here matches the
+ * provenance a {@linkcode PluginAnalysisDaylightApi} run echoes. Dates cross as
+ * ISO 8601 date strings (`"YYYY-MM-DD"`); each row's `timestamp` is a local
+ * ISO 8601 string **with** its UTC offset, and `utcOffsetMinutes` restates the
+ * offset so consumers never re-derive it.
+ *
+ * Reads never throw for "no data": when the project has no geo-located site
+ * (no weather file to resolve) the host surfaces that per its read contract.
+ *
+ * Accessed via `snaptrude.analysis.weather`.
+ */
+export declare abstract class PluginAnalysisWeatherApi {
+    constructor();
+    /**
+     * Get the hourly weather series for a date range, paged.
+     *
+     * Returns the resolved weather file's provenance (`source`) plus the weather
+     * `rows` for the requested range. The page size is backend-chosen; when
+     * `nextCursor` is a string, pass it back as `args.cursor` to fetch the next
+     * page, and stop when it is `null`.
+     *
+     * @param args - {@linkcode PluginWeatherGetSeriesArgs}: the inclusive
+     *   `startDate`/`endDate` ISO dates, an optional `interval` (`"hourly"` is
+     *   the only v1 value), and an optional `cursor` for paging.
+     * @returns A {@linkcode PluginWeatherSeriesResult} — the resolved weather
+     *   `source`, the `rows` for this page, and `nextCursor` (`null` at the end).
+     *
+     * @examplePrompt Get the weather series for June at my site
+     * @examplePrompt Pull the hourly temperature and irradiance for this location
+     * @examplePrompt What EPW weather file is my project using?
+     *
+     * # Example
+     * ```ts
+     * let cursor: string | undefined = undefined
+     * const rows = []
+     * do {
+     *   const page = await snaptrude.analysis.weather.getSeries({
+     *     startDate: "2026-06-01",
+     *     endDate: "2026-06-30",
+     *     cursor,
+     *   })
+     *   rows.push(...page.rows)
+     *   cursor = page.nextCursor ?? undefined
+     * } while (cursor)
+     * ```
+     */
+    abstract getSeries(args: PluginWeatherGetSeriesArgs): PluginApiReturn<PluginWeatherSeriesResult>;
+}
+/**
+ * How the weather file was matched to the project site.
+ *
+ * | Value | Meaning |
+ * |---|---|
+ * | `"nearest-station"` | Auto-resolved to the closest weather station |
+ * | `"user-upload"` | A weather file the user uploaded (`core.io.import.epw`) |
+ * | `"project-override"` | A station pinned for the project regardless of distance |
+ */
+export declare const PluginWeatherSelectionMethod: z.ZodEnum<{
+    "nearest-station": "nearest-station";
+    "user-upload": "user-upload";
+    "project-override": "project-override";
+}>;
+export type PluginWeatherSelectionMethod = z.infer<typeof PluginWeatherSelectionMethod>;
+/**
+ * Provenance of the resolved weather file — where the numbers came from.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `weatherFileId` | `string` | Catalog id (same key as `core.io.import.epw`'s `weatherFileId`) |
+ * | `station` | `string` | Station/file name, e.g. `"USA_IL_Chicago-OHare.Intl.AP.725300_TMY3"` |
+ * | `sourceId` | `string` | WMO/station identifier from the EPW header |
+ * | `distanceKm` | `number \| null` | Station → project site distance, km; `null` for pinned project-override files |
+ * | `selectionMethod` | {@linkcode PluginWeatherSelectionMethod} | How the file was matched |
+ * | `checksum` | `string` | sha256 of the EPW file — the provenance key |
+ * | `windReferenceHeightM` | `number` | Anemometer height the wind rows are valid at |
+ */
+export declare const PluginWeatherSourceMeta: z.ZodObject<{
+    weatherFileId: z.ZodString;
+    station: z.ZodString;
+    sourceId: z.ZodString;
+    distanceKm: z.ZodNullable<z.ZodNumber>;
+    selectionMethod: z.ZodEnum<{
+        "nearest-station": "nearest-station";
+        "user-upload": "user-upload";
+        "project-override": "project-override";
+    }>;
+    checksum: z.ZodString;
+    windReferenceHeightM: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginWeatherSourceMeta = z.infer<typeof PluginWeatherSourceMeta>;
+/**
+ * One hourly weather reading.
+ *
+ * `flags` is empty for a clean measured/typical value; known flag strings are
+ * `"missing"`, `"substituted"`, and `"interpolated"` (kept as `string[]` so the
+ * backend can add flag kinds without a contract break).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `timestamp` | `string` | Local ISO 8601 with offset, e.g. `"2026-06-21T14:00:00+05:30"` |
+ * | `utcOffsetMinutes` | `number` | UTC offset in minutes (restates the timestamp's offset) |
+ * | `dryBulbC` | `number` | Dry-bulb temperature, °C |
+ * | `relativeHumidityPercent` | `number` | Relative humidity, % |
+ * | `windSpeedMps` | `number` | Wind speed, m/s (at `source.windReferenceHeightM`) |
+ * | `ghiWm2` | `number` | Global horizontal irradiance, W/m² |
+ * | `dniWm2` | `number` | Direct normal irradiance, W/m² |
+ * | `dhiWm2` | `number` | Diffuse horizontal irradiance, W/m² |
+ * | `flags` | `string[]` | Quality flags; `[]` = clean value |
+ */
+export declare const PluginWeatherRow: z.ZodObject<{
+    timestamp: z.ZodString;
+    utcOffsetMinutes: z.ZodNumber;
+    dryBulbC: z.ZodNumber;
+    relativeHumidityPercent: z.ZodNumber;
+    windSpeedMps: z.ZodNumber;
+    ghiWm2: z.ZodNumber;
+    dniWm2: z.ZodNumber;
+    dhiWm2: z.ZodNumber;
+    flags: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type PluginWeatherRow = z.infer<typeof PluginWeatherRow>;
+/**
+ * Arguments for {@linkcode PluginAnalysisWeatherApi.getSeries}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `startDate` | `string` | Inclusive range start, ISO `"YYYY-MM-DD"` |
+ * | `endDate` | `string` | Inclusive range end, ISO `"YYYY-MM-DD"` |
+ * | `interval` | `"hourly"`? | Sampling interval; `"hourly"` is the only v1 value |
+ * | `cursor` | `string`? | Paging cursor from a prior page's `nextCursor` |
+ */
+export declare const PluginWeatherGetSeriesArgs: z.ZodObject<{
+    startDate: z.ZodString;
+    endDate: z.ZodString;
+    interval: z.ZodOptional<z.ZodEnum<{
+        hourly: "hourly";
+    }>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PluginWeatherGetSeriesArgs = z.infer<typeof PluginWeatherGetSeriesArgs>;
+/**
+ * Result of {@linkcode PluginAnalysisWeatherApi.getSeries} — one page.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `source` | {@linkcode PluginWeatherSourceMeta} | The resolved weather file's provenance |
+ * | `rows` | {@linkcode PluginWeatherRow}`[]` | Weather rows for this page |
+ * | `nextCursor` | `string \| null` | Pass back as `args.cursor`; `null` = last page |
+ * | `warnings` | `string[]`? | Degradation notices (e.g. `"override lookup failed; served nearest-station"`); omitted when the page is clean |
+ */
+export declare const PluginWeatherSeriesResult: z.ZodObject<{
+    source: z.ZodObject<{
+        weatherFileId: z.ZodString;
+        station: z.ZodString;
+        sourceId: z.ZodString;
+        distanceKm: z.ZodNullable<z.ZodNumber>;
+        selectionMethod: z.ZodEnum<{
+            "nearest-station": "nearest-station";
+            "user-upload": "user-upload";
+            "project-override": "project-override";
+        }>;
+        checksum: z.ZodString;
+        windReferenceHeightM: z.ZodNumber;
+    }, z.core.$strip>;
+    rows: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        utcOffsetMinutes: z.ZodNumber;
+        dryBulbC: z.ZodNumber;
+        relativeHumidityPercent: z.ZodNumber;
+        windSpeedMps: z.ZodNumber;
+        ghiWm2: z.ZodNumber;
+        dniWm2: z.ZodNumber;
+        dhiWm2: z.ZodNumber;
+        flags: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PluginWeatherSeriesResult = z.infer<typeof PluginWeatherSeriesResult>;
+//# sourceMappingURL=weather.d.ts.map

package/dist/api/analysis/weather.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weather.d.ts","sourceRoot":"","sources":["../../../src/api/analysis/weather.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8BAAsB,wBAAwB;;IAG5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;aACa,SAAS,CACvB,IAAI,EAAE,0BAA0B,GAC/B,eAAe,CAAC,yBAAyB,CAAC;CAC9C;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B;;;;EAIvC,CAAA;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,4BAA4B,CACpC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;iBAQlC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;iBAU3B,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B;;;;;;;iBAKrC,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,0BAA0B,CAClC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKpC,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,yBAAyB,CACjC,CAAA"}