import { KnownCapabilityName } from "./knownCapabilities";
/**
 * How claims against this capability behave.
 * - "countable": N interchangeable units, count-exclusive (v1 semantics).
 * - "fractional": shareable by capacity; today only the GPU pool models
 *   this (`GpuResource`), and the capability entry covers the whole-device
 *   exclusive claim alongside it.
 * - "identity": entries are physically distinct and non-interchangeable —
 *   one advertised entry per device, distinguished by attributes (a capture
 *   card is wherever its cable is plugged in).
 *
 * @public
 */
export type CapabilityKind = "countable" | "fractional" | "identity";
/**
 * How a worker discovers this capability. Declarative device-node globs
 * cover the simple presence checks; anything richer registers a named
 * probe implementation on the worker side. Capabilities with no probe are
 * declared in worker config — operational knowledge (which NIC sits on
 * the media VLAN) that probing cannot know.
 *
 * @public
 */
export type CapabilityProbe = {
    kind: "device-nodes";
    globs: string[];
} | {
    kind: "named";
    id: string;
};
/**
 * What granting this capability does to a launch — the declarative half of
 * the old per-name switches. The launch machinery interprets these fields
 * generically; CDI-vs-legacy GPU delivery stays a *mode* inside the one
 * nvidia entry rather than a reason for a second vocabulary.
 *
 * @public
 */
export interface CapabilityLaunchEffect {
    /** Plain compose `devices:` mappings, e.g. "/dev/netint:/dev/netint". */
    composeDevices?: string[];
    /** CDI device names when the engine supports CDI, e.g. "nvidia.com/gpu=all". */
    cdiDevices?: string[];
    /** Fall back to the docker `deploy.resources.reservations` GPU request
     *  when CDI is unavailable (the pre-CDI nvidia runtime path). */
    legacyGpuReservation?: boolean;
    /** Host group whose gid the container user must carry to reach the
     *  device (Quadra's /dev/netint* is group `disk`). */
    gidGroup?: string;
    /** Sideload bundle this hardware wants alongside the product (e.g. CUDA). */
    sideloadKey?: string;
}
/** @public */
export interface CapabilityDefinition {
    name: KnownCapabilityName;
    kind: CapabilityKind;
    /** Human-facing name for requirement selectors and inventory views. */
    displayName: string;
    /** Attribute keys this capability conventionally carries — schema-lite,
     *  for form rendering and validation hints, not enforcement. */
    attributeKeys?: string[];
    /** Absent = never probed; the worker's config declares it or a
     *  NodeService provides it. */
    probe?: CapabilityProbe;
    launchEffect?: CapabilityLaunchEffect;
}
/**
 * One entry per known capability. Growth happens here.
 *
 * @public
 */
export declare const CapabilityRegistry: Record<KnownCapabilityName, CapabilityDefinition>;
/** Every registry entry, for consumers that iterate. @public */
export declare function allCapabilityDefinitions(): CapabilityDefinition[];
//# sourceMappingURL=capabilityRegistry.d.ts.map