@camstack/types 0.1.14 → 0.1.16

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * snapshot-provider — collection of native snapshot implementations.
+ *
+ * Device provider addons (ONVIF, Frigate, Scrypted, etc.) register here
+ * when they can capture frames through a protocol-native path (e.g.
+ * ONVIF GetSnapshotUri, Frigate /api/<cam>/latest.jpg). The `snapshot`
+ * singleton orchestrator iterates over the collection, asking each
+ * provider whether it supports the requested device, and calls the
+ * first matching one.
+ *
+ * If no provider in the collection supports a device, the orchestrator
+ * falls back to `stream-broker.grabFrame` (universal fallback).
+ *
+ * Public tRPC router (auto-mounted) so out-of-process addons, agents,
+ * and advanced clients can bypass the orchestrator when needed.
+ */
+export declare const snapshotProviderCapability: {
+    readonly name: "snapshot-provider";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly methods: {
+        readonly supportsDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getSnapshot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            streamId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            base64: z.ZodString;
+            contentType: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type ISnapshotProvider = InferProvider<typeof snapshotProviderCapability> & {
+    readonly id: string;
+    readonly name: string;
+};
+//# sourceMappingURL=snapshot-provider.cap.d.ts.map

package/dist/capabilities/snapshot-provider.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/snapshot-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAGlG;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;CAiBE,CAAA;AAEzC,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,0BAA0B,CAAC,GAAG;IACjF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAA"}

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

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * A single device snapshot returned as base64 JPEG/PNG.
+ *
+ * Shared with the `snapshot-provider` collection cap — the orchestrator
+ * receives the same shape from each native provider and from the
+ * broker-based fallback.
+ */
+declare const SnapshotImageSchema: z.ZodObject<{
+    base64: z.ZodString;
+    contentType: z.ZodString;
+}, z.core.$strip>;
+/**
+ * snapshot — device-scoped capability for camera image capture.
+ *
+ * Two kinds of providers coexist behind this cap name:
+ *
+ *   - **Native** providers (kind:'native'): registered per-device by
+ *     device-driver addons (RtspCamera, OnvifCamera, …) via
+ *     `DeviceContext.registerNativeCap`. Each knows how to fetch a frame
+ *     straight from the camera (HTTP snapshot URL, ONVIF action, etc.).
+ *
+ *   - **Wrapper** providers (kind:'wrapper'): register as a system
+ *     provider (SnapshotAddon in `@camstack/core/builtins/snapshot`). The
+ *     wrapper owns the cache and invokes the native via
+ *     `ctx.getNativeProvider(snapshotCapability, deviceId)` on miss.
+ *
+ * Device-scoped routing: callers use `ctx.fetchDevice(id).snapshot.*`;
+ * the DeviceProxy auto-injects `deviceId` + `nodeId` and dispatches to
+ * the provider currently active for that device (wrapper wins when
+ * activated via `setWrapperActive`, otherwise the native).
+ */
+/**
+ * Live readable snapshot state — diagnostic info that a consumer can
+ * pull to know when the last image was captured, how stale the cache
+ * is, and which stream was used. Distinct from `getSnapshot` which
+ * returns the JPEG itself.
+ */
+declare const SnapshotStatusSchema: z.ZodObject<{
+    lastCapturedAt: z.ZodNullable<z.ZodNumber>;
+    cacheAgeMs: z.ZodNullable<z.ZodNumber>;
+    lastBytes: z.ZodNullable<z.ZodNumber>;
+    lastStreamId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const snapshotCapability: {
+    readonly name: "snapshot";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly exposesDeviceSettings: true;
+    readonly methods: {
+        readonly getSnapshot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            streamId: z.ZodOptional<z.ZodString>;
+            force: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            base64: z.ZodString;
+            contentType: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly invalidateCache: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            lastCapturedAt: z.ZodNullable<z.ZodNumber>;
+            cacheAgeMs: z.ZodNullable<z.ZodNumber>;
+            lastBytes: z.ZodNullable<z.ZodNumber>;
+            lastStreamId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        readonly kind: "poll";
+    };
+};
+export type ISnapshotOrchestrator = InferProvider<typeof snapshotCapability>;
+export { SnapshotImageSchema, SnapshotStatusSchema };
+//# sourceMappingURL=snapshot.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/snapshot.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;GAMG;AACH,QAAA,MAAM,mBAAmB;;;iBAGvB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB;;;;;iBASxB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCU,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE5E,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,CAAA"}

package/dist/capabilities/storage-provider.cap.d.ts

@@ -0,0 +1,432 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const ProviderInfoSchema: z.ZodObject<{
+    providerId: z.ZodString;
+    displayName: z.ZodString;
+    supportedLocationTypes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        data: "data";
+        media: "media";
+        recordings: "recordings";
+        cache: "cache";
+        logs: "logs";
+        models: "models";
+        "recordings-high": "recordings-high";
+        "recordings-low": "recordings-low";
+        "recordings-clips": "recordings-clips";
+        "event-images": "event-images";
+        "addons-data": "addons-data";
+        backups: "backups";
+    }>>>;
+    configSchema: z.ZodUnknown;
+}, z.core.$strip>;
+declare const TestLocationResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const BeginUploadInputSchema: z.ZodObject<{
+    location: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            data: "data";
+            media: "media";
+            recordings: "recordings";
+            cache: "cache";
+            logs: "logs";
+            models: "models";
+            "recordings-high": "recordings-high";
+            "recordings-low": "recordings-low";
+            "recordings-clips": "recordings-clips";
+            "event-images": "event-images";
+            "addons-data": "addons-data";
+            backups: "backups";
+        }>;
+        displayName: z.ZodString;
+        providerId: z.ZodString;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        isSystem: z.ZodDefault<z.ZodBoolean>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, z.core.$strip>;
+    relativePath: z.ZodString;
+    sizeBytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const BeginUploadResultSchema: z.ZodObject<{
+    uploadId: z.ZodString;
+}, z.core.$strip>;
+declare const WriteChunkInputSchema: z.ZodObject<{
+    uploadId: z.ZodString;
+    offset: z.ZodNumber;
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+}, z.core.$strip>;
+declare const FinalizeUploadInputSchema: z.ZodObject<{
+    uploadId: z.ZodString;
+}, z.core.$strip>;
+declare const AbortUploadInputSchema: z.ZodObject<{
+    uploadId: z.ZodString;
+}, z.core.$strip>;
+declare const BeginDownloadInputSchema: z.ZodObject<{
+    location: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            data: "data";
+            media: "media";
+            recordings: "recordings";
+            cache: "cache";
+            logs: "logs";
+            models: "models";
+            "recordings-high": "recordings-high";
+            "recordings-low": "recordings-low";
+            "recordings-clips": "recordings-clips";
+            "event-images": "event-images";
+            "addons-data": "addons-data";
+            backups: "backups";
+        }>;
+        displayName: z.ZodString;
+        providerId: z.ZodString;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        isSystem: z.ZodDefault<z.ZodBoolean>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, z.core.$strip>;
+    relativePath: z.ZodString;
+}, z.core.$strip>;
+declare const BeginDownloadResultSchema: z.ZodObject<{
+    downloadId: z.ZodString;
+    sizeBytes: z.ZodNumber;
+}, z.core.$strip>;
+declare const ReadChunkInputSchema: z.ZodObject<{
+    downloadId: z.ZodString;
+    offset: z.ZodNumber;
+    length: z.ZodNumber;
+}, z.core.$strip>;
+declare const EndDownloadInputSchema: z.ZodObject<{
+    downloadId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * storage-provider — collection capability for backend-specific storage
+ * drivers.
+ *
+ * Multiple addons register against this cap (filesystem-storage,
+ * sftp-storage, s3-storage, webdav-storage, …). The orchestrator
+ * (singleton `storage` cap, owned by the storage-orchestrator builtin)
+ * routes each call to the right provider by looking up
+ * `location.providerId` and dispatching the inline `location` arg.
+ *
+ * Design notes:
+ *   - Stateless dispatch: every primitive carries its own `location`,
+ *     so providers don't keep per-location state across calls.
+ *   - Session-scoped uploads/downloads: the `uploadId`/`downloadId`
+ *     handles let the provider hold open file descriptors / streams
+ *     between chunks while keeping the cap surface RPC-friendly.
+ *   - `internal: true` — this cap is consumed only by the storage
+ *     orchestrator. Public consumers go through the `storage`
+ *     singleton cap; they never see `storage-provider` directly.
+ */
+export declare const storageProviderCapability: {
+    readonly name: "storage-provider";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        /** Self-description for the "Add location" wizard. */
+        readonly getProviderInfo: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            providerId: z.ZodString;
+            displayName: z.ZodString;
+            supportedLocationTypes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                data: "data";
+                media: "media";
+                recordings: "recordings";
+                cache: "cache";
+                logs: "logs";
+                models: "models";
+                "recordings-high": "recordings-high";
+                "recordings-low": "recordings-low";
+                "recordings-clips": "recordings-clips";
+                "event-images": "event-images";
+                "addons-data": "addons-data";
+                backups: "backups";
+            }>>>;
+            configSchema: z.ZodUnknown;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Validate config + probe connectivity. Called on add and on edit. */
+        readonly testLocation: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly resolve: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    data: "data";
+                    media: "media";
+                    recordings: "recordings";
+                    cache: "cache";
+                    logs: "logs";
+                    models: "models";
+                    "recordings-high": "recordings-high";
+                    "recordings-low": "recordings-low";
+                    "recordings-clips": "recordings-clips";
+                    "event-images": "event-images";
+                    "addons-data": "addons-data";
+                    backups: "backups";
+                }>;
+                displayName: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                isDefault: z.ZodDefault<z.ZodBoolean>;
+                isSystem: z.ZodDefault<z.ZodBoolean>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+            relativePath: z.ZodString;
+        }, z.core.$strip>, z.ZodString, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly write: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    data: "data";
+                    media: "media";
+                    recordings: "recordings";
+                    cache: "cache";
+                    logs: "logs";
+                    models: "models";
+                    "recordings-high": "recordings-high";
+                    "recordings-low": "recordings-low";
+                    "recordings-clips": "recordings-clips";
+                    "event-images": "event-images";
+                    "addons-data": "addons-data";
+                    backups: "backups";
+                }>;
+                displayName: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                isDefault: z.ZodDefault<z.ZodBoolean>;
+                isSystem: z.ZodDefault<z.ZodBoolean>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+            relativePath: z.ZodString;
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly read: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    data: "data";
+                    media: "media";
+                    recordings: "recordings";
+                    cache: "cache";
+                    logs: "logs";
+                    models: "models";
+                    "recordings-high": "recordings-high";
+                    "recordings-low": "recordings-low";
+                    "recordings-clips": "recordings-clips";
+                    "event-images": "event-images";
+                    "addons-data": "addons-data";
+                    backups: "backups";
+                }>;
+                displayName: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                isDefault: z.ZodDefault<z.ZodBoolean>;
+                isSystem: z.ZodDefault<z.ZodBoolean>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+            relativePath: z.ZodString;
+        }, z.core.$strip>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly exists: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    data: "data";
+                    media: "media";
+                    recordings: "recordings";
+                    cache: "cache";
+                    logs: "logs";
+                    models: "models";
+                    "recordings-high": "recordings-high";
+                    "recordings-low": "recordings-low";
+                    "recordings-clips": "recordings-clips";
+                    "event-images": "event-images";
+                    "addons-data": "addons-data";
+                    backups: "backups";
+                }>;
+                displayName: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                isDefault: z.ZodDefault<z.ZodBoolean>;
+                isSystem: z.ZodDefault<z.ZodBoolean>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+            relativePath: z.ZodString;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    data: "data";
+                    media: "media";
+                    recordings: "recordings";
+                    cache: "cache";
+                    logs: "logs";
+                    models: "models";
+                    "recordings-high": "recordings-high";
+                    "recordings-low": "recordings-low";
+                    "recordings-clips": "recordings-clips";
+                    "event-images": "event-images";
+                    "addons-data": "addons-data";
+                    backups: "backups";
+                }>;
+                displayName: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                isDefault: z.ZodDefault<z.ZodBoolean>;
+                isSystem: z.ZodDefault<z.ZodBoolean>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+            prefix: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodString>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly delete: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    data: "data";
+                    media: "media";
+                    recordings: "recordings";
+                    cache: "cache";
+                    logs: "logs";
+                    models: "models";
+                    "recordings-high": "recordings-high";
+                    "recordings-low": "recordings-low";
+                    "recordings-clips": "recordings-clips";
+                    "event-images": "event-images";
+                    "addons-data": "addons-data";
+                    backups: "backups";
+                }>;
+                displayName: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                isDefault: z.ZodDefault<z.ZodBoolean>;
+                isSystem: z.ZodDefault<z.ZodBoolean>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+            relativePath: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly getAvailableSpace: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    data: "data";
+                    media: "media";
+                    recordings: "recordings";
+                    cache: "cache";
+                    logs: "logs";
+                    models: "models";
+                    "recordings-high": "recordings-high";
+                    "recordings-low": "recordings-low";
+                    "recordings-clips": "recordings-clips";
+                    "event-images": "event-images";
+                    "addons-data": "addons-data";
+                    backups: "backups";
+                }>;
+                displayName: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                isDefault: z.ZodDefault<z.ZodBoolean>;
+                isSystem: z.ZodDefault<z.ZodBoolean>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodNumber>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly beginUpload: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    data: "data";
+                    media: "media";
+                    recordings: "recordings";
+                    cache: "cache";
+                    logs: "logs";
+                    models: "models";
+                    "recordings-high": "recordings-high";
+                    "recordings-low": "recordings-low";
+                    "recordings-clips": "recordings-clips";
+                    "event-images": "event-images";
+                    "addons-data": "addons-data";
+                    backups: "backups";
+                }>;
+                displayName: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                isDefault: z.ZodDefault<z.ZodBoolean>;
+                isSystem: z.ZodDefault<z.ZodBoolean>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+            relativePath: z.ZodString;
+            sizeBytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            uploadId: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        readonly writeChunk: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            uploadId: z.ZodString;
+            offset: z.ZodNumber;
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly finalizeUpload: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            uploadId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly abortUpload: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            uploadId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly beginDownload: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    data: "data";
+                    media: "media";
+                    recordings: "recordings";
+                    cache: "cache";
+                    logs: "logs";
+                    models: "models";
+                    "recordings-high": "recordings-high";
+                    "recordings-low": "recordings-low";
+                    "recordings-clips": "recordings-clips";
+                    "event-images": "event-images";
+                    "addons-data": "addons-data";
+                    backups: "backups";
+                }>;
+                displayName: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                isDefault: z.ZodDefault<z.ZodBoolean>;
+                isSystem: z.ZodDefault<z.ZodBoolean>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+            relativePath: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            downloadId: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        readonly readChunk: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            downloadId: z.ZodString;
+            offset: z.ZodNumber;
+            length: z.ZodNumber;
+        }, z.core.$strip>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly endDownload: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            downloadId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+};
+export type IStorageProviderImpl = InferProvider<typeof storageProviderCapability>;
+export { ProviderInfoSchema, TestLocationResultSchema, BeginUploadInputSchema, BeginUploadResultSchema, WriteChunkInputSchema, FinalizeUploadInputSchema, AbortUploadInputSchema, BeginDownloadInputSchema, BeginDownloadResultSchema, ReadChunkInputSchema, EndDownloadInputSchema, };
+//# sourceMappingURL=storage-provider.cap.d.ts.map

package/dist/capabilities/storage-provider.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/storage-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAgBlG,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;iBAKtB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;iBAG5B,CAAA;AAcF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI1B,CAAA;AACF,QAAA,MAAM,uBAAuB;;iBAAqC,CAAA;AAClE,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AACF,QAAA,MAAM,yBAAyB;;iBAAqC,CAAA;AACpE,QAAA,MAAM,sBAAsB;;iBAAqC,CAAA;AAMjE,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG5B,CAAA;AACF,QAAA,MAAM,yBAAyB;;;iBAG7B,CAAA;AACF,QAAA,MAAM,oBAAoB;;;;iBAIxB,CAAA;AACF,QAAA,MAAM,sBAAsB;;iBAAuC,CAAA;AAEnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,yBAAyB;;;;;;QAMlC,sDAAsD;;;;;;;;;;;;;;;;;;;;QAGtD,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDlC,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAElF,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,sBAAsB,GACvB,CAAA"}