@camstack/types 1.2.59 → 1.2.61

package/dist/capabilities/index.d.ts

@@ -180,7 +180,7 @@ export { type IPtzProvider, PtzMoveCommandSchema, type PtzOptions, PtzOptionsSch
 export { type IPtzAutotrackProvider, type PtzAutotrackRuntimeState, PtzAutotrackRuntimeStateSchema, type PtzAutotrackSettings, PtzAutotrackSettingsSchema, type PtzAutotrackStatus, PtzAutotrackStatusSchema, type PtzAutotrackTargetOption, PtzAutotrackTargetOptionSchema, ptzAutotrackCapability, } from './ptz-autotrack.cap.js';
 export { type IRebootProvider, rebootCapability } from './reboot.cap.js';
 export { type IRecordingProvider, type LocateSegmentResult, LocateSegmentResultSchema, type ReadGopBytesResult, ReadGopBytesResultSchema, type ReadSegmentBytesResult, ReadSegmentBytesResultSchema, type RecordingAvailability, RecordingAvailabilitySchema, type RecordingDays, RecordingDaysSchema, type RecordingDeviceUsage, RecordingDeviceUsageSchema, type RecordingLocationUsage, RecordingLocationUsageSchema, type RecordingManifest, RecordingManifestSchema, RecordingRangeSchema, type RecordingStatus, RecordingStatusSchema, type RecordingStorageUsage, RecordingStorageUsageSchema, recordingCapability, } from './recording.cap.js';
-export { type ExportDownload, ExportDownloadSchema, type ExportOptions, ExportOptionsSchema, type ExportRecord, ExportRecordSchema, ExportSpeedSchema, type ExportState, ExportStateSchema, ExportTimelapseSchema, type IRecordingExportProvider, recordingExportCapability, } from './recording-export.cap.js';
+export { EXPORT_DENSE_MAX_RANGES, RECORDING_EXPORT_MAX_READ_BYTES, type ExportBytes, ExportBytesSchema, type ExportDense, type ExportDenseRange, ExportDenseRangeSchema, ExportDenseSchema, type ExportDownload, ExportDownloadSchema, type ExportOptions, ExportOptionsSchema, type ExportRecord, ExportRecordSchema, ExportSpeedSchema, type ExportState, ExportStateSchema, ExportTimelapseSchema, type IRecordingExportProvider, recordingExportCapability, } from './recording-export.cap.js';
 export { type ISceneMonitorProvider, type SceneCheck, SceneCheckSchema, type SceneCondition, SceneConditionSchema, type SceneMonitor, SceneMonitorSchema, type SceneMonitorState, SceneMonitorStateSchema, type SceneMonitorStatus, SceneMonitorStatusSchema, type SceneReference, SceneReferenceSchema, sceneMonitorCapability, } from './scene-monitor.cap.js';
 export { type ZoneRule, type ZoneRuleMode, ZoneRuleModeEnum, ZoneRuleSchema, type ZoneRules, ZoneRulesArraySchema, } from './schemas/zone-rule.js';
 export { type IScriptRunnerProvider, type ScriptRunnerStatus, ScriptRunnerStatusSchema, scriptRunnerCapability, } from './script-runner.cap.js';

package/dist/capabilities/pipeline-orchestrator.cap.d.ts

@@ -1146,6 +1146,10 @@ export declare const pipelineOrchestratorCapability: {
             }, z.core.$strip>>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
+         * @deprecated The aggregate switch group is being withdrawn
+         * ([D113](../../../../docs/decisions/adr-0113.md)). Build nothing new on
+         * this pair; read the authority directly.
+         *
          * The whole per-camera function switch group, DERIVED — never a stored
          * list ([D61](../../../../docs/decisions/adr-0067.md)).
          *
@@ -1159,6 +1163,16 @@ export declare const pipelineOrchestratorCapability: {
          * `auth: 'view'` deliberately — a NON-admin must be able to see that a
          * camera is quiet because somebody switched it off. Only the mutation is
          * admin-gated.
+         *
+         * **Removal plan.** It stays and it KEEPS WORKING while shipped viewers
+         * (v1.0.305) and the admin UI still call it — removing it now is a broken
+         * app on a device nobody can redeploy from here. It is served by a thin
+         * shim over the same authorities (`camera-switch-service.ts`), so the
+         * behaviour of the pair is the behaviour of the authorities by
+         * construction. It is deleted once every surface reaches its own
+         * component's options and the last caller is gone. Nothing on this server
+         * reads it: `CameraStatus.switchedOff` is composed from the authorities
+         * directly via `composeSwitchedOff`.
          */
         readonly getCameraSwitches: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
@@ -1206,6 +1220,10 @@ export declare const pipelineOrchestratorCapability: {
             fetchedAt: z.ZodNumber;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
+         * @deprecated See {@link getCameraSwitches}. Write the authority — the
+         * wrapper binding, `RecordingConfig.enabled`, the notification mute — not
+         * this ([D113](../../../../docs/decisions/adr-0113.md)).
+         *
          * Flip ONE switch, routed to its existing authority.
          *
          * Never writes a parallel map: `recording` patches `RecordingConfig.enabled`

package/dist/capabilities/recording-export.cap.d.ts

@@ -16,10 +16,56 @@ import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 /** Playback-speed multiplier for the render (1 = realtime). */
 export declare const ExportSpeedSchema: z.ZodNumber;
+/**
+ * One dense interval, in SECONDS FROM THE EXPORT'S OWN `fromMs`.
+ *
+ * Relative and not absolute epoch on purpose: the renderer's frame-select
+ * expression sees ffmpeg's `t`, which starts at 0 for the export's source
+ * playlist. Handing it absolute epochs would make every call site responsible
+ * for the same subtraction, and the one that forgot would emit a filter that
+ * selects nothing — silently, as a uniform timelapse.
+ */
+export declare const ExportDenseRangeSchema: z.ZodObject<{
+    fromSec: z.ZodNumber;
+    toSec: z.ZodNumber;
+}, z.core.$strip>;
+export type ExportDenseRange = z.infer<typeof ExportDenseRangeSchema>;
+/**
+ * Hard ceiling on dense ranges in ONE render.
+ *
+ * The ranges become terms of a single ffmpeg `select` expression, so the count
+ * is the length of a command-line argument. The producer (the timelapse
+ * scheduler) coalesces and then falls back to the base cadence alone rather
+ * than trimming — a truncated range list is a video that quietly omits the
+ * evening.
+ */
+export declare const EXPORT_DENSE_MAX_RANGES = 200;
+/**
+ * Dense-interval overlay for a timelapse: sample at `dense.everyMs` INSIDE the
+ * listed ranges and at the base `everyMs` everywhere else.
+ *
+ * `everyMs` must be strictly smaller than the base cadence — a dense rate that
+ * is not denser renders a uniform timelapse the operator believes is two-rate.
+ */
+export declare const ExportDenseSchema: z.ZodObject<{
+    everyMs: z.ZodNumber;
+    ranges: z.ZodArray<z.ZodObject<{
+        fromSec: z.ZodNumber;
+        toSec: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ExportDense = z.infer<typeof ExportDenseSchema>;
 /** Timelapse cadence — sample one source frame per `everyMs`, output at `outputFps`. */
 export declare const ExportTimelapseSchema: z.ZodObject<{
     everyMs: z.ZodNumber;
     outputFps: z.ZodOptional<z.ZodNumber>;
+    dense: z.ZodOptional<z.ZodObject<{
+        everyMs: z.ZodNumber;
+        ranges: z.ZodArray<z.ZodObject<{
+            fromSec: z.ZodNumber;
+            toSec: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * Render options. `speed` and `timelapse` are mutually exclusive. `includeAudio`
@@ -32,6 +78,13 @@ export declare const ExportOptionsSchema: z.ZodObject<{
     timelapse: z.ZodOptional<z.ZodObject<{
         everyMs: z.ZodNumber;
         outputFps: z.ZodOptional<z.ZodNumber>;
+        dense: z.ZodOptional<z.ZodObject<{
+            everyMs: z.ZodNumber;
+            ranges: z.ZodArray<z.ZodObject<{
+                fromSec: z.ZodNumber;
+                toSec: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     includeAudio: z.ZodBoolean;
     maxLifeMs: z.ZodNumber;
@@ -60,6 +113,13 @@ export declare const ExportRecordSchema: z.ZodObject<{
         timelapse: z.ZodOptional<z.ZodObject<{
             everyMs: z.ZodNumber;
             outputFps: z.ZodOptional<z.ZodNumber>;
+            dense: z.ZodOptional<z.ZodObject<{
+                everyMs: z.ZodNumber;
+                ranges: z.ZodArray<z.ZodObject<{
+                    fromSec: z.ZodNumber;
+                    toSec: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
         includeAudio: z.ZodBoolean;
         maxLifeMs: z.ZodNumber;
@@ -90,6 +150,38 @@ export declare const ExportDownloadSchema: z.ZodObject<{
     endpoints: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
 export type ExportDownload = z.infer<typeof ExportDownloadSchema>;
+/**
+ * Hard ceiling on ONE {@link recordingExportCapability} byte read — 50 MiB.
+ *
+ * Two independent reasons land on the same number, which is why it is this one
+ * and not a rounder guess:
+ *
+ *  - **Nobody would accept more.** The roomiest byte cap any notifier backend
+ *    declares is telegram's 50 MiB, and the degrade engine DROPS an over-cap
+ *    attachment outright rather than degrading it to a link. Bytes above this
+ *    are read, encoded and moved to be thrown away at the last step.
+ *  - **The envelope is unary.** A base64 payload is held whole, ~1.33× its
+ *    size, in the provider AND in the caller — on a hub this repo has already
+ *    OOM'd once (D9/D18). A bounded on-demand read at human speed is the shape
+ *    those records permit; an unbounded one is the shape they forbid.
+ *
+ * Above it the provider REFUSES with a log line rather than truncating: half a
+ * video is worse than a notification that says there is no attachment.
+ */
+export declare const RECORDING_EXPORT_MAX_READ_BYTES: number;
+/**
+ * A finished export's bytes, inline.
+ *
+ * `bytes` is the DECODED length — the number the caller bounds and logs
+ * against, so nobody has to infer it from the base64 length.
+ */
+export declare const ExportBytesSchema: z.ZodObject<{
+    base64: z.ZodString;
+    contentType: z.ZodString;
+    name: z.ZodString;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export type ExportBytes = z.infer<typeof ExportBytesSchema>;
 export declare const recordingExportCapability: {
     readonly name: "recordingExport";
     readonly scope: "system";
@@ -107,6 +199,13 @@ export declare const recordingExportCapability: {
                 timelapse: z.ZodOptional<z.ZodObject<{
                     everyMs: z.ZodNumber;
                     outputFps: z.ZodOptional<z.ZodNumber>;
+                    dense: z.ZodOptional<z.ZodObject<{
+                        everyMs: z.ZodNumber;
+                        ranges: z.ZodArray<z.ZodObject<{
+                            fromSec: z.ZodNumber;
+                            toSec: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
                 }, z.core.$strip>>;
                 includeAudio: z.ZodBoolean;
                 maxLifeMs: z.ZodNumber;
@@ -124,6 +223,13 @@ export declare const recordingExportCapability: {
                 timelapse: z.ZodOptional<z.ZodObject<{
                     everyMs: z.ZodNumber;
                     outputFps: z.ZodOptional<z.ZodNumber>;
+                    dense: z.ZodOptional<z.ZodObject<{
+                        everyMs: z.ZodNumber;
+                        ranges: z.ZodArray<z.ZodObject<{
+                            fromSec: z.ZodNumber;
+                            toSec: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
                 }, z.core.$strip>>;
                 includeAudio: z.ZodBoolean;
                 maxLifeMs: z.ZodNumber;
@@ -161,6 +267,13 @@ export declare const recordingExportCapability: {
                 timelapse: z.ZodOptional<z.ZodObject<{
                     everyMs: z.ZodNumber;
                     outputFps: z.ZodOptional<z.ZodNumber>;
+                    dense: z.ZodOptional<z.ZodObject<{
+                        everyMs: z.ZodNumber;
+                        ranges: z.ZodArray<z.ZodObject<{
+                            fromSec: z.ZodNumber;
+                            toSec: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
                 }, z.core.$strip>>;
                 includeAudio: z.ZodBoolean;
                 maxLifeMs: z.ZodNumber;
@@ -197,6 +310,13 @@ export declare const recordingExportCapability: {
                 timelapse: z.ZodOptional<z.ZodObject<{
                     everyMs: z.ZodNumber;
                     outputFps: z.ZodOptional<z.ZodNumber>;
+                    dense: z.ZodOptional<z.ZodObject<{
+                        everyMs: z.ZodNumber;
+                        ranges: z.ZodArray<z.ZodObject<{
+                            fromSec: z.ZodNumber;
+                            toSec: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
                 }, z.core.$strip>>;
                 includeAudio: z.ZodBoolean;
                 maxLifeMs: z.ZodNumber;
@@ -234,6 +354,13 @@ export declare const recordingExportCapability: {
                 timelapse: z.ZodOptional<z.ZodObject<{
                     everyMs: z.ZodNumber;
                     outputFps: z.ZodOptional<z.ZodNumber>;
+                    dense: z.ZodOptional<z.ZodObject<{
+                        everyMs: z.ZodNumber;
+                        ranges: z.ZodArray<z.ZodObject<{
+                            fromSec: z.ZodNumber;
+                            toSec: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
                 }, z.core.$strip>>;
                 includeAudio: z.ZodBoolean;
                 maxLifeMs: z.ZodNumber;
@@ -271,6 +398,13 @@ export declare const recordingExportCapability: {
                 timelapse: z.ZodOptional<z.ZodObject<{
                     everyMs: z.ZodNumber;
                     outputFps: z.ZodOptional<z.ZodNumber>;
+                    dense: z.ZodOptional<z.ZodObject<{
+                        everyMs: z.ZodNumber;
+                        ranges: z.ZodArray<z.ZodObject<{
+                            fromSec: z.ZodNumber;
+                            toSec: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
                 }, z.core.$strip>>;
                 includeAudio: z.ZodBoolean;
                 maxLifeMs: z.ZodNumber;
@@ -300,6 +434,31 @@ export declare const recordingExportCapability: {
             url: z.ZodString;
             endpoints: z.ZodArray<z.ZodString>;
         }, z.core.$strip>, "query">;
+        /**
+         * The finished file's BYTES, base64, for a caller that must republish them
+         * somewhere a session-less fetcher can reach.
+         *
+         * `getDownloadUrl` is the right answer for a human: the download route is
+         * served `access: 'authenticated'`, which a browser satisfies and a
+         * notifier BACKEND does not. It answers a RELATIVE path, so it is not even
+         * a URL an outside fetcher could try. This method exists for the one case
+         * that needs the other thing — a scheduled timelapse whose video has to
+         * become a public attachment on the notification artifact plane.
+         *
+         * Deliberately narrow: `ready` only (a queued, rendering, failed, expired
+         * or deleted export has no file, and answering "0 bytes" for one is how a
+         * caller ships an empty attachment), still inside its lifetime, and under
+         * {@link RECORDING_EXPORT_MAX_READ_BYTES}. Every refusal throws with the
+         * reason — none of them is silent.
+         */
+        readonly readExportBytes: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            exportId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            base64: z.ZodString;
+            contentType: z.ZodString;
+            name: z.ZodString;
+            bytes: z.ZodNumber;
+        }, z.core.$strip>, "query">;
     };
 };
 export type IRecordingExportProvider = InferProvider<typeof recordingExportCapability>;

package/dist/capabilities/snapshot.cap.d.ts

@@ -90,24 +90,28 @@ export declare const snapshotCapability: {
          *
          * `getSnapshotOverview` is cache-only by contract: it answers from whatever
          * the wrapper happens to hold and never captures. Under D93 the client
-         * versions its image URL on that answer, and an image REQUEST is what enrols
-         * a camera in the keep-warm loop. Both of those are satisfiable by the
-         * client's own image cache — `expo-image` is URL-keyed and never revalidates
-         * — so a URL painted in a previous session comes off disk with no network,
-         * no enrolment, and nothing warming. Measured on the live hub: reopening
-         * after two minutes idle painted 15 of 16 tiles at **168 s old** with zero
-         * HTTP requests, and the fleet only recovered because a later poll happened
-         * to observe a different identity.
+         * versions its image URL on that answer, and an image REQUEST was the only
+         * demand signal. Both of those are satisfiable by the client's own image
+         * cache — `expo-image` is URL-keyed and never revalidates — so a URL painted
+         * in a previous session comes off disk with no network, no demand, and no
+         * capture. Measured on the live hub: reopening after two minutes idle
+         * painted 15 of 16 tiles at **168 s old** with zero HTTP requests, and the
+         * fleet only recovered because a later poll happened to observe a different
+         * identity.
          *
          * ## The two properties that fix it
          *
          * **It is an RPC, so no client cache can answer it.** The demand signal
-         * always reaches the wrapper. This method therefore MAY create keep-warm
-         * subscriptions, where `getSnapshotOverview` must never (D93) — the
-         * distinction is not "one is newer" but that the overview poll is app-wide
-         * (a creating overview would warm every camera on the install) while this is
-         * called by a rendered surface naming the tiles it is actually painting, at
-         * the width it is painting them.
+         * always reaches the wrapper. This method therefore CAPTURES, where
+         * `getSnapshotOverview` must never (D93) — the distinction is not "one is
+         * newer" but that the overview poll is app-wide (a capturing overview would
+         * dial every camera on the install) while this is called by a rendered
+         * surface naming the tiles it is actually painting, at the width it is
+         * painting them.
+         *
+         * Since 2026-08-11 this is the ONLY thing that refreshes a snapshot: the
+         * server-side keep-warm loop was removed (operator directive — on-demand,
+         * always), so a camera nobody is looking at costs nothing at all.
          *
          * **It waits, briefly and boundedly, for the capture it triggered.** The
          * returned `capturedAt` is the frame the link will serve, not the frame the

package/dist/device/declared-device.d.ts

@@ -193,6 +193,18 @@ export declare class DeclaredDevices {
      */
     private ensureIntegration;
     private readIndex;
+    /**
+     * Devices this kernel already has CONSTRUCTED, by stableId.
+     *
+     * Distinct from {@link readIndex}, and the distinction is the bug: the index
+     * is persisted rows, this is live objects. A row without an object must be
+     * adopted; an object must be left exactly as it is.
+     *
+     * Failure is non-fatal and deliberately so — an empty map degrades to the
+     * previous behaviour (attempt the adopt) rather than skipping a device that
+     * genuinely needs bringing up.
+     */
+    private readLiveByStableId;
     /**
      * One declaration: adopt what exists, create what does not.
      *

package/dist/generated/addon-api.d.ts

@@ -6359,6 +6359,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof recordingExportCapability.methods.getDownloadUrl.output>;
             meta: object;
         }>;
+        readExportBytes: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordingExportCapability.methods.readExportBytes.input>;
+            output: z.infer<typeof recordingExportCapability.methods.readExportBytes.output>;
+            meta: object;
+        }>;
     }>>;
     sceneMonitor: TRPCBuiltRouter<{
         ctx: TrpcContext;

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 927 method paths across 123 capabilities.
+ * Coverage: 928 method paths across 123 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/generated/system-proxy.d.ts

@@ -88,7 +88,7 @@ export interface SystemProxy {
     readonly pipelineRunner: Pick<InferProvider<typeof pipelineRunnerCapability>, 'attachCamera' | 'reportMotion' | 'getLocalLoad' | 'getLocalMetrics' | 'getAllCameraMetrics' | 'getLocalCameras' | 'getNativeCrop' | 'runStatelessStep'>;
     readonly plateGallery: Pick<InferProvider<typeof plateGalleryCapability>, 'getPlateMedia' | 'searchPlates' | 'suggestPlateClusters' | 'correctPlateText' | 'deletePlate' | 'listVehicles' | 'createVehicle' | 'renameVehicle' | 'deleteVehicle' | 'listVehicleSamples' | 'removeVehicleSample' | 'assignPlate' | 'unassignPlate' | 'assignPlates' | 'unassignPlates'>;
     readonly recording: Pick<InferProvider<typeof recordingCapability>, 'getStorageUsage' | 'listOpsLog' | 'pauseForStorageMigration' | 'resumeForStorageMigration' | 'refreshStorageLocationsForMigration' | 'startStorageMigrationMove' | 'getStorageMigrationMoveStatus' | 'cancelStorageMigrationMove'>;
-    readonly recordingExport: Pick<InferProvider<typeof recordingExportCapability>, 'getExport' | 'cancelExport' | 'deleteExport' | 'getDownloadUrl'>;
+    readonly recordingExport: Pick<InferProvider<typeof recordingExportCapability>, 'getExport' | 'cancelExport' | 'deleteExport' | 'getDownloadUrl' | 'readExportBytes'>;
     readonly serverManagement: Pick<InferProvider<typeof serverManagementCapability>, 'getServerPackageStatus' | 'checkServerUpdate' | 'applyServerUpdate' | 'rollbackServerUpdate' | 'restartServer'>;
     readonly settingsStore: Pick<InferProvider<typeof settingsStoreCapability>, 'get' | 'set' | 'query' | 'insert' | 'update' | 'delete' | 'deleteWhere' | 'updateWhere' | 'count' | 'histogram' | 'isEmpty' | 'declareCollection'>;
     readonly storage: Pick<InferProvider<typeof storageCapability>, 'resolve' | 'write' | 'read' | 'exists' | 'list' | 'delete' | 'getAvailableSpace' | 'beginUpload' | 'writeChunk' | 'finalizeUpload' | 'abortUpload' | 'beginDownload' | 'readChunk' | 'endDownload' | 'listLocations' | 'getDefaultLocation' | 'listLocationDeclarations' | 'upsertLocation' | 'deleteLocation' | 'testLocation' | 'listProviders' | 'testConfig'>;

package/dist/index.d.ts

@@ -189,7 +189,7 @@ export { type PreparedAction, type PreparedAttachment, type PreparedNotification
 export { htmlToText, markdownToHtmlLite, markdownToText, type NotificationFormat as NotificationBodyFormat, resolveFormat, textToHtml, transcodeBody, } from './notification/format-transcode.js';
 export { isScheduleActive } from './notification/schedule.js';
 export type { TimelapseRule, TimelapseRuleInput, TimelapseRulePatch, TimelapseTemplate, } from './notification/timelapse-rule.js';
-export { TimelapseRuleInputSchema, TimelapseRulePatchSchema, TimelapseRuleSchema, TimelapseTemplateSchema, } from './notification/timelapse-rule.js';
+export { readTimelapseGeneratedAt, TimelapseRuleInputSchema, TimelapseRulePatchSchema, TimelapseRuleSchema, TimelapseTemplateSchema, } from './notification/timelapse-rule.js';
 export { DEFAULT_DETAIL_CROP_CONVENTION, DETAIL_CROP_PADDING_FIELD, DETAIL_CROP_PADDING_KEY, DETAIL_CROP_SECTION_ID, DETAIL_CROP_SQUARE_KEY, type DetailCropConvention, DetailCropConventionSchema, type DetailCropRect, deriveDetailCropRect, type HydratedSettingsSection, type HydratedSettingsView, pickDetailCropConvention, readDetailCropConvention, } from './pipeline/detail-crop.js';
 export { DEFAULT_NATIVE_LEASE_SETTINGS, NATIVE_LEASE_ACTIVITY_FIELD, NATIVE_LEASE_ACTIVITY_KEY, NATIVE_LEASE_ADMISSION_FIELD, NATIVE_LEASE_ADMISSION_KEY, NATIVE_LEASE_BUDGET_FIELD, NATIVE_LEASE_BUDGET_KEY, NATIVE_LEASE_SECTION_ID, NATIVE_LEASE_TTL_FIELD, NATIVE_LEASE_TTL_KEY, type NativeLeaseAdmission, NativeLeaseAdmissionSchema, type NativeLeaseKnob, type NativeLeaseNumberKnob, type NativeLeaseSettings, type NativeLeaseSettingsOverride, NativeLeaseSettingsSchema, pickNativeLeaseOverride, readNativeLeaseOverride, } from './pipeline/native-lease.js';
 export { type ApiKeyRecord, ApiKeyRecordSchema, type CapScope, CapScopeSchema, type MethodAccess, MethodAccessSchema, type ScopedToken, ScopedTokenSchema, type TokenScope, TokenScopeSchema, type UserRecord, UserRecordSchema, } from './schemas/auth-records.js';