import { z } from 'zod';
/**
 * `StorageLocationType` — the closed enum of *kinds* of storage a location
 * can serve. Defined here (not in `capabilities/storage.cap.ts`) so the
 * persisted record schema and the consumer-facing cap can both consume it
 * without forming a circular import. The `storage` cap re-exports it
 * verbatim for back-compat.
 *
 * This Zod schema is the **authoritative source** for `StorageLocationType`.
 * The TS alias in `./storage.ts` re-exports `z.infer<typeof
 * StorageLocationTypeSchema>` so the wire surface (cap) and the legacy
 * `IStorageProvider` interface stay in lockstep.
 */
export declare const StorageLocationTypeSchema: 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";
}>;
/**
 * `StorageLocationType` — TS alias for the Zod enum above. Re-exported
 * by `./storage.ts` so the legacy `IStorageProvider` interface keeps the
 * same name without duplicating the literal union.
 */
export type StorageLocationType = z.infer<typeof StorageLocationTypeSchema>;
/**
 * Cardinality of a storage location type:
 *
 *  - `singleton` — exactly one location instance allowed system-wide.
 *    Multiple instances would split state in a way that breaks
 *    consumers (e.g. two `addons-data` roots → addon's persistent
 *    state lands in either or both; two `cache` roots → cache misses
 *    on every read; two `data` roots → sqlite path bifurcation).
 *    Operators can EDIT the singleton's config (path / providerId)
 *    but never add a second instance. The seed always creates the
 *    initial default.
 *
 *  - `multi` — multiple instances are first-class. Operators add
 *    secondary locations (e.g. NAS + local SSD for `recordings`,
 *    offsite + on-disk for `backups`). One is `isDefault: true`
 *    at any moment; others are addressable via fully-qualified id.
 *
 * Used by `StorageOrchestratorService.upsertLocation` to reject
 * "Add" attempts on singleton types, and by the admin UI to hide
 * the "+ Add location" button on those groups.
 */
export declare const STORAGE_LOCATION_CARDINALITY: Readonly<Record<StorageLocationType, 'singleton' | 'multi'>>;
/**
 * Persisted record for a storage location instance. Multi-instance
 * (per `STORAGE_LOCATION_CARDINALITY[type]`) — operators can register
 * e.g. two `backups` locations (one filesystem, one SFTP) with
 * different `providerId`s, but only one `cache`/`data`/etc.
 *
 * `id` is a stable namespaced string of the form `<type>:<slug>`.
 * The default location for a type uses `id === <type>:default` by
 * convention (the bare type ref like `'backups'` resolves to it).
 *
 * `isSystem: true` marks a location as orchestrator-seeded and
 * undeletable. The bootstrap-installed defaults (one per type) carry
 * this flag; operator-added locations don't. Editing the config of
 * a system location is allowed (path migration, provider swap) but
 * deleting it is rejected at the cap level.
 */
export declare const StorageLocationSchema: 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>;
export type StorageLocation = z.infer<typeof StorageLocationSchema>;
/**
 * Reference accepted by consumer-facing `api.storage.*` calls.
 * Either:
 *  - a `StorageLocationType` (e.g. `'backups'`) → orchestrator resolves to the default of that type
 *  - a fully-qualified id (e.g. `'backups:nas-01'`) → addresses a specific instance
 *
 * The orchestrator's `resolveRef(ref)` handles both cases.
 */
export declare const StorageLocationRefSchema: 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]>;
export type StorageLocationRef = z.infer<typeof StorageLocationRefSchema>;
//# sourceMappingURL=storage-location.d.ts.map