@camstack/types 0.1.14 → 0.1.16

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

@@ -0,0 +1,367 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { StorageLocationTypeSchema } from '../interfaces/storage-location.js';
+/**
+ * `storage` — singleton consumer-facing capability owned by the
+ * `storage-orchestrator` builtin (Task 4 of the storage-unification
+ * refactor). All file I/O across the system flows through this cap;
+ * the orchestrator resolves each `location` ref to a concrete
+ * `StorageLocation` record and dispatches to the matching
+ * `storage-provider` registrant.
+ *
+ * The `location` parameter on every primitive is a `StorageLocationRef`
+ * — either a bare `StorageLocationType` (e.g. `'backups'`, resolves to
+ * the default of that type) or a fully-qualified id (`'backups:nas-01'`,
+ * addresses a specific instance). Both forms are normalised inside the
+ * orchestrator's `resolveRef(ref)` step.
+ *
+ * Mode: `singleton` (was `collection` pre-Task-3). The cap-router mount
+ * uses `requireSingleton(reg, 'storage')` — pointing at the orchestrator
+ * once it lands.
+ */
+export declare const storageCapability: {
+    readonly name: "storage";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly resolve: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodUnion<readonly [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";
+            }>, z.ZodString]>;
+            relativePath: z.ZodString;
+        }, z.core.$strip>, z.ZodString, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly write: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodUnion<readonly [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";
+            }>, z.ZodString]>;
+            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.ZodUnion<readonly [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";
+            }>, z.ZodString]>;
+            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.ZodUnion<readonly [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";
+            }>, z.ZodString]>;
+            relativePath: z.ZodString;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodUnion<readonly [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";
+            }>, z.ZodString]>;
+            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.ZodUnion<readonly [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";
+            }>, z.ZodString]>;
+            relativePath: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly getAvailableSpace: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodUnion<readonly [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";
+            }>, z.ZodString]>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodNumber>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly beginUpload: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            location: z.ZodUnion<readonly [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";
+            }>, z.ZodString]>;
+            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.ZodUnion<readonly [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";
+            }>, z.ZodString]>;
+            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">;
+        readonly listLocations: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            type: z.ZodOptional<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";
+            }>>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<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>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getDefaultLocation: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            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";
+            }>;
+        }, z.core.$strip>, z.ZodNullable<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>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly upsertLocation: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            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";
+            }>;
+            id: z.ZodString;
+            displayName: z.ZodString;
+            providerId: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            isDefault: z.ZodDefault<z.ZodBoolean>;
+            isSystem: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, 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>, "mutation">;
+        readonly deleteLocation: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly testLocation: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly listProviders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<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>;
+        readonly testConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            providerId: z.ZodString;
+            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>;
+    };
+};
+export type IStorageCapProvider = InferProvider<typeof storageCapability>;
+export { StorageLocationTypeSchema };
+//# sourceMappingURL=storage.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storage.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/storage.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAGL,yBAAyB,EAC1B,MAAM,mCAAmC,CAAA;AAE1C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6HW,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEzE,OAAO,EAAE,yBAAyB,EAAE,CAAA"}