@serve.zone/interfaces 32.15.0 → 32.17.0

package/dist_ts/data/clusterrelaycredential.d.ts

@@ -0,0 +1,141 @@
+import type { IClusterRelayAcceptedRegistration } from './cluster.js';
+import type { IFleetCutoverAcceptedEvidenceReference } from './fleetcutover.js';
+import type { TSha256Digest } from './immutableimage.js';
+import type { IRuntimeAuthorityReference } from './runtimeassignment.js';
+import type { ISecretVersionReference } from './secret.js';
+/**
+ * The relay authority Cloudly mints for one cluster. Public metadata only: never a bearer or hash.
+ *
+ * It authenticates the cluster's whole control-plane session, exactly what the shared cluster
+ * authority authenticated before it, so the relay changes one credential and keeps every call it
+ * makes. What it adds is a generation Cloudly fences each socket against and an authority it can
+ * rotate without touching the shared one; its scope is not narrower. One cluster has one relay and
+ * therefore one such record, and rotation is its whole lifecycle: it never expires by itself.
+ */
+export interface IClusterRelayCredential {
+    id: string;
+    clusterId: string;
+    /** Monotonic state: one accepted mint or rotation advances it by exactly one. */
+    generation: number;
+    /** The machine identity this credential authenticates as; Cloudly's own, never caller-chosen. */
+    userId: string;
+    /** The immutable encrypted version the bearer was delivered as. */
+    delivery: ISecretVersionReference;
+    actorId: string;
+    acceptedAt: number;
+    digest: TSha256Digest;
+}
+interface IClusterRelayCredentialMutationBase {
+    clusterId: string;
+    /** Retain the complete request and this ID across retries; a changed body with it fails closed. */
+    mutationId: string;
+}
+/**
+ * Creation is absent-only; rotation requires the exact current generation, never a minimum.
+ *
+ * There is no revocation: a rotation already ends the previous generation at commit, so it covers a
+ * compromised credential without a state in which the cluster has no relay authority at all.
+ */
+export type TClusterRelayCredentialMutation = IClusterRelayCredentialMutationBase & ({
+    operation: 'ensure';
+    expectedGeneration: null;
+} | {
+    operation: 'rotate';
+    expectedGeneration: number;
+});
+export interface IClusterRelayCredentialMutationResult {
+    credential: IClusterRelayCredential;
+    /** The shared pre-relay authority this cluster still carries; null when no record names one. */
+    legacy: IClusterLegacyRelayCredential | null;
+    /** A replay returns the original result without renewing delivery, generation or authority. */
+    replayed: boolean;
+}
+/**
+ * Cloudly's record of the shared cluster authority that predates the relay credential, so it can
+ * be named and retired. It is the machine identity every cluster-side component authenticated as;
+ * like the relay credential it carries no bearer and no hash.
+ */
+export interface IClusterLegacyRelayCredential {
+    id: string;
+    clusterId: string;
+    userId: string;
+    generation: number;
+    state: 'active' | 'revoked';
+    /**
+     * The accepted invalidation that revoked it; null exactly while it is still accepted.
+     *
+     * The invalidation names this record at the generation before the revocation and this record
+     * names the invalidation at the generation after it, so neither digest covers the other's.
+     */
+    invalidation: IFleetCutoverAcceptedEvidenceReference | null;
+    recordedAt: number;
+    digest: TSha256Digest;
+}
+/**
+ * Caller intent only. Both references are compare-and-swap inputs: Cloudly dereferences them
+ * against its own current records and checks the relay's live socket itself.
+ */
+export interface IClusterLegacyRelayCredentialRetirementRequest {
+    /** Retain the complete request and this ID across retries; a changed body with it fails closed. */
+    mutationId: string;
+    clusterId: string;
+    expectedLegacyGeneration: number;
+    /** The exact replacement relay credential generation the caller observed as current. */
+    replacement: IRuntimeAuthorityReference;
+    /** The exact accepted registration the caller observed as current. */
+    acceptedRegistration: IFleetCutoverAcceptedEvidenceReference;
+}
+/** The accepted receipt that one shared cluster authority stopped being accepted; written once. */
+export interface IClusterLegacyRelayCredentialInvalidation {
+    id: string;
+    generation: 1;
+    clusterId: string;
+    /** The exact legacy generation this invalidated, read before the record advanced. */
+    credential: IRuntimeAuthorityReference;
+    /** The relay credential generation that was current when this was accepted. */
+    replacement: IRuntimeAuthorityReference;
+    /** The registration that was current, made under `replacement`, and live when this was accepted. */
+    acceptedRegistration: IFleetCutoverAcceptedEvidenceReference;
+    actorId: string;
+    acceptedAt: number;
+    digest: TSha256Digest;
+}
+export interface IClusterLegacyRelayCredentialRetirementResult {
+    credential: IClusterLegacyRelayCredential;
+    invalidation: IClusterLegacyRelayCredentialInvalidation;
+    /** A replay returns the recorded invalidation; nothing is revoked twice. */
+    replayed: boolean;
+}
+export declare const clusterRelayCredentialContract: Readonly<{
+    readonly credentialDigestDomain: "serve.zone/cluster-relay-credential";
+    readonly legacyCredentialDigestDomain: "serve.zone/cluster-relay-legacy-credential";
+    readonly legacyInvalidationDigestDomain: "serve.zone/cluster-relay-legacy-credential-invalidation";
+}>;
+/** Every reason Cloudly answers instead of mutating or retiring a cluster relay authority. */
+export declare const clusterRelayCredentialRefusals: readonly ["relay-credential-absent", "legacy-credential-absent", "legacy-credential-already-retired", "legacy-retirement-replacement-not-current", "legacy-retirement-registration-not-current", "legacy-retirement-relay-not-live", "conflict"];
+export type TClusterRelayCredentialRefusal = typeof clusterRelayCredentialRefusals[number];
+/** Structural copy only; whether the record is the cluster's current one is Cloudly's to decide. */
+export declare const snapshotClusterRelayCredential: (valueArg: unknown) => IClusterRelayCredential;
+export declare const computeClusterRelayCredentialDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+export declare const validateClusterRelayCredential: (valueArg: unknown) => Promise<string[]>;
+export declare const snapshotClusterRelayCredentialMutation: (valueArg: unknown) => TClusterRelayCredentialMutation;
+export declare const snapshotClusterLegacyRelayCredential: (valueArg: unknown) => IClusterLegacyRelayCredential;
+export declare const computeClusterLegacyRelayCredentialDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+export declare const validateClusterLegacyRelayCredential: (valueArg: unknown) => Promise<string[]>;
+export declare const snapshotClusterLegacyRelayCredentialRetirementRequest: (valueArg: unknown) => IClusterLegacyRelayCredentialRetirementRequest;
+export declare const snapshotClusterLegacyRelayCredentialInvalidation: (valueArg: unknown) => IClusterLegacyRelayCredentialInvalidation;
+export declare const computeClusterLegacyRelayCredentialInvalidationDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+export declare const validateClusterLegacyRelayCredentialInvalidation: (valueArg: unknown) => Promise<string[]>;
+/**
+ * Joins an invalidation to the shared authority it revoked and to the registration that justified
+ * it, which must have been made under the very replacement the invalidation names.
+ *
+ * Content join only. Cloudly must still dereference each record as its cluster's current one and
+ * require a live verified socket for the registration while holding its compare-and-swap.
+ */
+export declare const bindClusterLegacyRelayCredentialInvalidation: (invalidationArg: unknown, legacyCredentialArg: unknown, acceptedRegistrationArg: unknown) => Promise<{
+    invalidation: IClusterLegacyRelayCredentialInvalidation;
+    legacyCredential: IClusterLegacyRelayCredential;
+    acceptedRegistration: IClusterRelayAcceptedRegistration;
+}>;
+export {};

package/dist_ts/data/clusterrelaycredential.js

@@ -0,0 +1,192 @@
+import { snapshotClusterRelayAcceptedRegistration, validateClusterRelayAcceptedRegistration, } from './cluster.js';
+import { captureNetwork, networkCounter, networkDigest, networkEqual, networkHash, networkId, networkRecord, networkReference, networkReferenceOf, requireNetwork, } from '../private/networkcontract.js';
+export const clusterRelayCredentialContract = Object.freeze({
+    credentialDigestDomain: 'serve.zone/cluster-relay-credential',
+    legacyCredentialDigestDomain: 'serve.zone/cluster-relay-legacy-credential',
+    legacyInvalidationDigestDomain: 'serve.zone/cluster-relay-legacy-credential-invalidation',
+});
+/** Every reason Cloudly answers instead of mutating or retiring a cluster relay authority. */
+export const clusterRelayCredentialRefusals = Object.freeze([
+    /** A rotation named a cluster that has no relay credential yet. */
+    'relay-credential-absent',
+    /** A retirement named a cluster whose shared authority no record names. */
+    'legacy-credential-absent',
+    /** The shared authority is already revoked; its invalidation is written once. */
+    'legacy-credential-already-retired',
+    /** The named replacement is not the cluster's relay credential at its current generation. */
+    'legacy-retirement-replacement-not-current',
+    /** The named registration is not current, or it was made under another credential generation. */
+    'legacy-retirement-registration-not-current',
+    /** No verified socket carries the named registration at the instant of acceptance. */
+    'legacy-retirement-relay-not-live',
+    /** An expected generation was not the exact current one, or a mutation ID met a changed body. */
+    'conflict',
+]);
+const fail = () => { throw new Error('Cluster relay credential contract rejected.'); };
+const safe = (operationArg) => {
+    try {
+        return operationArg();
+    }
+    catch {
+        return fail();
+    }
+};
+const secretVersionReference = (valueArg) => {
+    const value = networkRecord(valueArg, ['secretId', 'secretVersionId']);
+    return {
+        secretId: networkId(value.secretId),
+        secretVersionId: networkId(value.secretVersionId),
+    };
+};
+/** Structural copy only; whether the record is the cluster's current one is Cloudly's to decide. */
+export const snapshotClusterRelayCredential = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'id', 'clusterId', 'generation', 'userId', 'delivery', 'actorId', 'acceptedAt', 'digest',
+    ]);
+    return {
+        id: networkId(value.id),
+        clusterId: networkId(value.clusterId),
+        generation: networkCounter(value.generation),
+        userId: networkId(value.userId),
+        delivery: secretVersionReference(value.delivery),
+        actorId: networkId(value.actorId),
+        acceptedAt: networkCounter(value.acceptedAt),
+        digest: networkDigest(value.digest),
+    };
+});
+export const computeClusterRelayCredentialDigest = async (valueArg) => networkHash(clusterRelayCredentialContract.credentialDigestDomain, snapshotClusterRelayCredential(valueArg));
+export const validateClusterRelayCredential = async (valueArg) => {
+    try {
+        const value = snapshotClusterRelayCredential(valueArg);
+        return value.digest === await computeClusterRelayCredentialDigest(value)
+            ? [] : ['cluster relay credential digest does not match'];
+    }
+    catch {
+        return ['cluster relay credential must use its exact canonical schema'];
+    }
+};
+export const snapshotClusterRelayCredentialMutation = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'clusterId', 'mutationId', 'operation', 'expectedGeneration',
+    ]);
+    const base = { clusterId: networkId(value.clusterId), mutationId: networkId(value.mutationId) };
+    const operation = value.operation;
+    requireNetwork(operation === 'ensure' || operation === 'rotate');
+    if (operation === 'ensure') {
+        requireNetwork(value.expectedGeneration === null);
+        return { ...base, operation, expectedGeneration: null };
+    }
+    return { ...base, operation, expectedGeneration: networkCounter(value.expectedGeneration) };
+});
+export const snapshotClusterLegacyRelayCredential = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'id', 'clusterId', 'userId', 'generation', 'state', 'invalidation', 'recordedAt', 'digest',
+    ]);
+    const state = value.state;
+    requireNetwork(state === 'active' || state === 'revoked');
+    const generation = networkCounter(value.generation);
+    const invalidation = value.invalidation === null ? null : networkReference(value.invalidation);
+    // Revoked exactly when an invalidation names it, and only as the successor of an active record.
+    requireNetwork(state === 'active'
+        ? invalidation === null
+        : invalidation !== null && invalidation.generation === 1 && generation > 1);
+    return {
+        id: networkId(value.id),
+        clusterId: networkId(value.clusterId),
+        userId: networkId(value.userId),
+        generation,
+        state,
+        invalidation,
+        recordedAt: networkCounter(value.recordedAt),
+        digest: networkDigest(value.digest),
+    };
+});
+export const computeClusterLegacyRelayCredentialDigest = async (valueArg) => networkHash(clusterRelayCredentialContract.legacyCredentialDigestDomain, snapshotClusterLegacyRelayCredential(valueArg));
+export const validateClusterLegacyRelayCredential = async (valueArg) => {
+    try {
+        const value = snapshotClusterLegacyRelayCredential(valueArg);
+        return value.digest === await computeClusterLegacyRelayCredentialDigest(value)
+            ? [] : ['cluster legacy relay credential digest does not match'];
+    }
+    catch {
+        return ['cluster legacy relay credential must use its exact canonical schema'];
+    }
+};
+export const snapshotClusterLegacyRelayCredentialRetirementRequest = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'mutationId', 'clusterId', 'expectedLegacyGeneration', 'replacement', 'acceptedRegistration',
+    ]);
+    return {
+        mutationId: networkId(value.mutationId),
+        clusterId: networkId(value.clusterId),
+        expectedLegacyGeneration: networkCounter(value.expectedLegacyGeneration),
+        replacement: networkReference(value.replacement),
+        acceptedRegistration: networkReference(value.acceptedRegistration),
+    };
+});
+export const snapshotClusterLegacyRelayCredentialInvalidation = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'id', 'generation', 'clusterId', 'credential', 'replacement', 'acceptedRegistration',
+        'actorId', 'acceptedAt', 'digest',
+    ]);
+    requireNetwork(value.generation === 1);
+    return {
+        id: networkId(value.id),
+        generation: 1,
+        clusterId: networkId(value.clusterId),
+        credential: networkReference(value.credential),
+        replacement: networkReference(value.replacement),
+        acceptedRegistration: networkReference(value.acceptedRegistration),
+        actorId: networkId(value.actorId),
+        acceptedAt: networkCounter(value.acceptedAt),
+        digest: networkDigest(value.digest),
+    };
+});
+export const computeClusterLegacyRelayCredentialInvalidationDigest = async (valueArg) => networkHash(clusterRelayCredentialContract.legacyInvalidationDigestDomain, snapshotClusterLegacyRelayCredentialInvalidation(valueArg));
+export const validateClusterLegacyRelayCredentialInvalidation = async (valueArg) => {
+    try {
+        const value = snapshotClusterLegacyRelayCredentialInvalidation(valueArg);
+        return value.digest === await computeClusterLegacyRelayCredentialInvalidationDigest(value)
+            ? [] : ['cluster legacy relay credential invalidation digest does not match'];
+    }
+    catch {
+        return ['cluster legacy relay credential invalidation must use its exact canonical schema'];
+    }
+};
+/**
+ * The active record is named exactly. The revoked one is that record's successor, so it is named
+ * by identity and the generation before it, and it names the invalidation back.
+ */
+const invalidationNamesLegacyCredential = (invalidationArg, legacyCredentialArg) => legacyCredentialArg.state === 'active'
+    ? networkEqual(invalidationArg.credential, networkReferenceOf(legacyCredentialArg))
+    : invalidationArg.credential.id === legacyCredentialArg.id
+        && invalidationArg.credential.generation === legacyCredentialArg.generation - 1
+        && networkEqual(legacyCredentialArg.invalidation, networkReferenceOf(invalidationArg));
+/**
+ * Joins an invalidation to the shared authority it revoked and to the registration that justified
+ * it, which must have been made under the very replacement the invalidation names.
+ *
+ * Content join only. Cloudly must still dereference each record as its cluster's current one and
+ * require a live verified socket for the registration while holding its compare-and-swap.
+ */
+export const bindClusterLegacyRelayCredentialInvalidation = async (invalidationArg, legacyCredentialArg, acceptedRegistrationArg) => {
+    try {
+        const invalidation = snapshotClusterLegacyRelayCredentialInvalidation(invalidationArg);
+        const legacyCredential = snapshotClusterLegacyRelayCredential(legacyCredentialArg);
+        const acceptedRegistration = snapshotClusterRelayAcceptedRegistration(acceptedRegistrationArg);
+        if ((await validateClusterLegacyRelayCredentialInvalidation(invalidation)).length
+            || (await validateClusterLegacyRelayCredential(legacyCredential)).length
+            || (await validateClusterRelayAcceptedRegistration(acceptedRegistration)).length)
+            fail();
+        requireNetwork(legacyCredential.clusterId === invalidation.clusterId
+            && acceptedRegistration.clusterId === invalidation.clusterId
+            && invalidationNamesLegacyCredential(invalidation, legacyCredential)
+            && networkEqual(invalidation.acceptedRegistration, networkReferenceOf(acceptedRegistration))
+            && networkEqual(invalidation.replacement, acceptedRegistration.credential));
+        return { invalidation, legacyCredential, acceptedRegistration };
+    }
+    catch {
+        return fail();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clusterrelaycredential.js","sourceRoot":"","sources":["../../ts/data/clusterrelaycredential.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/fleetcutover.d.ts

@@ -35,6 +35,33 @@ export interface IFleetCutoverMountTargetIdentityInput {
     /** Docker Engine Mount.Destination exact UTF-8 bytes; never normalize. */
     target: string;
 }
+export interface IFleetCutoverDockerMountInput {
+    /** Raw Docker mount type. Unsupported values produce an explicit unknown descriptor. */
+    type: string;
+    /** Exact source bytes from the Docker object being described; never substitute another field. */
+    source: string;
+    /** Exact container target bytes from the Docker object being described. */
+    target: string;
+    readOnly: boolean;
+}
+/**
+ * Value-free correlation between one local physical mount and its service-spec mount identity.
+ * The two identities stay distinct: a Docker volume's local Source is a host path while its
+ * service Source and local Name are the logical volume name.
+ */
+export interface IFleetCutoverPhysicalMountCorrelation {
+    physicalMountIdentityDigest: TSha256Digest;
+    serviceMountIdentityDigest: TSha256Digest;
+    correlationIdentityDigest: TSha256Digest;
+}
+export interface IFleetCutoverPhysicalMountEvidence {
+    mount: IFleetCutoverMountDescriptor;
+    correlation: IFleetCutoverPhysicalMountCorrelation;
+}
+export interface IFleetCutoverDockerConstraintSetIdentity {
+    constraintCount: number;
+    constraintSetDigest: TSha256Digest;
+}
 export type TFleetCutoverDockerTaskState = 'new' | 'allocated' | 'pending' | 'assigned' | 'accepted' | 'preparing' | 'ready' | 'starting' | 'running' | 'complete' | 'shutdown' | 'failed' | 'rejected' | 'remove' | 'orphaned';
 export type TFleetCutoverDockerDesiredState = TFleetCutoverDockerTaskState;
 export type TFleetCutoverDockerServiceMode = {
@@ -83,6 +110,11 @@ export interface IFleetCutoverPhysicalContainer {
     imageId: TSha256Digest;
     serviceIdLabel: string | null;
     mounts: IFleetCutoverMountDescriptor[];
+    /**
+     * Optional only for compatibility with observations predating correlation evidence. When
+     * present it is a complete one-to-one mapping of mounts. Absence establishes no mount join.
+     */
+    mountCorrelations?: IFleetCutoverPhysicalMountCorrelation[];
 }
 export interface IFleetCutoverContainerSetIdentity {
     containerCount: number;
@@ -554,6 +586,9 @@ export declare const fleetCutoverContract: Readonly<{
     readonly maximumNodes: 1024;
     readonly maximumContainersPerNode: 512;
     readonly maximumMountsPerOwner: 32;
+    readonly maximumConstraintsPerService: 256;
+    readonly maximumDockerTextBytes: 4096;
+    readonly maximumDockerServiceSpecCanonicalBytes: 1048576;
     readonly maximumPreparedVolumeHandoffMutationEntries: 32;
     /** Every admitted task has one node placement and at most 32 mounts: 4096 * 32. */
     readonly maximumPreparedVolumeHandoffs: number;
@@ -564,6 +599,9 @@ export declare const fleetCutoverContract: Readonly<{
     readonly mountSourceIdentityDigestDomain: "serve.zone/fleet-cutover-mount-source-identity";
     readonly mountTargetIdentityDigestDomain: "serve.zone/fleet-cutover-mount-target-identity";
     readonly mountIdentityDigestDomain: "serve.zone/fleet-cutover-mount-identity";
+    readonly mountCorrelationIdentityDigestDomain: "serve.zone/fleet-cutover-mount-correlation-identity";
+    readonly dockerServiceSpecDigestDomain: "serve.zone/fleet-cutover-docker-service-spec";
+    readonly dockerConstraintSetDigestDomain: "serve.zone/fleet-cutover-docker-constraint-set";
     readonly containerSetIdentityDigestDomain: "serve.zone/fleet-cutover-container-set-identity";
     readonly localNodeSnapshotDigestDomain: "serve.zone/fleet-cutover-local-node-snapshot";
     readonly managerSnapshotDigestDomain: "serve.zone/fleet-cutover-manager-snapshot";
@@ -588,9 +626,36 @@ export declare const fleetCutoverContract: Readonly<{
         pallet: null;
     }>;
 }>;
+/** Docker labels with established historical producer semantics. */
+export declare const fleetCutoverDockerLabelNames: Readonly<{
+    readonly serviceId: "serve.zone.serviceId";
+}>;
+/**
+ * Hash the complete open-schema Docker Service.Spec object. Unknown response properties are
+ * intentionally included: this helper returns only the digest and never a retained projection.
+ */
+export declare const computeFleetCutoverDockerServiceSpecDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+/** Sort exact constraint strings while preserving duplicate entries, then return value-free identity. */
+export declare const computeFleetCutoverDockerConstraintSetIdentity: (valueArg: unknown) => Promise<IFleetCutoverDockerConstraintSetIdentity>;
+export declare const snapshotFleetCutoverDockerDesiredTaskCount: (valueArg: unknown) => number;
+export declare const validateFleetCutoverDockerDesiredTaskCount: (valueArg: unknown) => string[];
+/** Apply only the documented exact cutover mount classifications; no path normalization occurs. */
+export declare const classifyFleetCutoverDockerMount: (valueArg: IFleetCutoverDockerMountInput) => Pick<IFleetCutoverMountDescriptor, "type" | "classification">;
+export declare const createFleetCutoverMountDescriptor: (valueArg: IFleetCutoverDockerMountInput) => Promise<IFleetCutoverMountDescriptor>;
+/** Read only consumed Service.Spec Mount fields; future Docker response properties are ignored. */
+export declare const createFleetCutoverDockerServiceMountDescriptor: (valueArg: unknown) => Promise<IFleetCutoverMountDescriptor>;
+/** Read only consumed local MountPoint fields and retain the exact physical Source identity. */
+export declare const createFleetCutoverDockerLocalMountDescriptor: (valueArg: unknown) => Promise<IFleetCutoverMountDescriptor>;
 export declare const computeFleetCutoverMountSourceIdentityDigest: (valueArg: IFleetCutoverMountSourceIdentityInput) => Promise<TSha256Digest>;
 export declare const computeFleetCutoverMountTargetIdentityDigest: (valueArg: IFleetCutoverMountTargetIdentityInput) => Promise<TSha256Digest>;
 export declare const computeFleetCutoverMountIdentityDigest: (valueArg: Omit<IFleetCutoverMountDescriptor, "mountIdentityDigest">) => Promise<TSha256Digest>;
+export declare const computeFleetCutoverMountCorrelationIdentityDigest: (valueArg: Omit<IFleetCutoverPhysicalMountCorrelation, "correlationIdentityDigest">) => Promise<TSha256Digest>;
+/**
+ * Produce both the exact local physical descriptor and its logical service-mount correlation.
+ * For a volume only MountPoint.Name supplies the logical source. Unknown types and a missing or
+ * empty volume Name are refused because they cannot establish a truthful service join.
+ */
+export declare const createFleetCutoverDockerPhysicalMountEvidence: (valueArg: unknown) => Promise<IFleetCutoverPhysicalMountEvidence>;
 export declare const computeFleetCutoverContainerSetIdentityDigest: (containerIdsArg: string[]) => Promise<TSha256Digest>;
 export declare const snapshotFleetCutoverLocalNodeSnapshot: (valueArg: unknown) => IFleetCutoverLocalNodeSnapshot;
 export declare const computeFleetCutoverLocalNodeSnapshotDigest: (valueArg: unknown) => Promise<TSha256Digest>;