@serve.zone/interfaces 14.0.0 → 16.0.0

package/changelog.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 2026-07-20 - 16.0.0
+
+### Breaking Changes
+
+- add attested existing-service adoption contracts (deployment)
+  - Add a mutation-free adoption preflight and a digest-fenced, idempotent adoption request.
+  - Require explicit service-scoped deployment:adopt-existing authority.
+  - Bind registry, release, target-scope, and healthy runtime digest evidence before switching a mutable service to immutable rollout state.
+
+## 2026-07-20 - 15.0.0
+
+### Breaking Changes
+
+- add scoped immutable deployment operation contracts (deployment)
+  - Replace machine deployment grant fields with an exact organization/service or organization/service-slot grant and use JWT-only credentials on scoped deployment RPCs.
+  - Add revisioned reserve, status, route promotion, retry, and cleanup contracts with complete configuration, rollout, wildcard-route, readiness, and TLS evidence validation.
+  - Require authenticated registry evidence bound to the operation, actor, service, image, registry host, repository, exact tag, root digest, and OCI index media type.
+  - Require promotion and rollback requests to carry exact operation/repository/tag/digest fences and immutable plans and verified runtime tasks to expose exact rollout and digest evidence.
+
 ## 2026-07-19 - 14.0.0
 
 ### Breaking Changes

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '14.0.0',
+    version: '16.0.0',
     description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHVGQUF1RjtDQUNyRyxDQUFBIn0=

package/dist_ts/data/deploymentadoption.d.ts

@@ -0,0 +1,95 @@
+import type { IDeploymentPreflightRuntimeTask, IOciPlatformDescriptorSummary } from './deploymentpreflight.js';
+import type { IImmutableImageDeploymentPlan, IImmutableImageTargetScope, TOciManifestMediaType, TSha256Digest } from './immutableimage.js';
+import type { IRegistryTarget } from './registry.js';
+export type TServiceDeploymentAdoptionDecision = 'GO' | 'NO-GO';
+/**
+ * Canonical sha256 hash of the complete adoption preflight snapshot. It is a
+ * state/TOCTOU fence and must never be substituted with the OCI image digest.
+ */
+export type TServiceDeploymentAdoptionDigest = TSha256Digest & {
+    readonly __serviceDeploymentAdoptionDigest: unique symbol;
+};
+export type TServiceDeploymentAdoptionBlockerCode = 'INVALID_REQUEST' | 'AUTHORIZATION_MISSING' | 'SERVICE_NOT_FOUND' | 'SERVICE_OWNERSHIP_MISMATCH' | 'SERVICE_ALREADY_IMMUTABLE' | 'SERVICE_STATE_CONFLICT' | 'REGISTRY_TARGET_MISSING' | 'REGISTRY_REFERENCE_INVALID' | 'REGISTRY_DIGEST_MISSING' | 'OCI_INDEX_REQUIRED' | 'OCI_PLATFORM_MISSING' | 'RELEASE_NOT_FOUND' | 'RELEASE_TAG_AMBIGUOUS' | 'TARGET_SCOPE_UNAVAILABLE' | 'RUNTIME_ATTESTATION_INCOMPLETE' | 'RUNTIME_DIGEST_MISMATCH';
+export interface IServiceDeploymentAdoptionBlocker {
+    code: TServiceDeploymentAdoptionBlockerCode;
+    message: string;
+}
+export interface IServiceDeploymentAdoptionPreflightInput {
+    requestId: string;
+    organizationId: string;
+    serviceId: string;
+}
+export interface IServiceDeploymentAdoptionInput extends IServiceDeploymentAdoptionPreflightInput {
+    idempotencyKey: string;
+    expectedAdoptionDigest: TServiceDeploymentAdoptionDigest;
+}
+interface IServiceDeploymentAdoptionReportBase {
+    schemaVersion: 1;
+    mutationPerformed: false;
+    requestId: string;
+    generatedAt: number;
+    runtimeAttestation: {
+        requiredReplicaCount: number;
+        observedReplicaCount: number;
+        healthyReplicaCount: number;
+        observedDigestReplicaCount: number;
+        observedDigestConsistent: boolean;
+    };
+}
+interface IServiceDeploymentAdoptionServiceSnapshot {
+    organizationId: string;
+    serviceId: string;
+    serviceName: string;
+    imageId: string;
+    deployOnPush: boolean;
+    immutableImageRequired: boolean;
+    configuredReference: string;
+    registryTarget: IRegistryTarget;
+}
+interface IServiceDeploymentAdoptionRegistrySnapshot {
+    tag?: string;
+    digest?: TSha256Digest;
+    mediaType?: TOciManifestMediaType;
+    platforms: IOciPlatformDescriptorSummary[];
+    releaseId?: string;
+    releaseTag?: string;
+}
+export interface IServiceDeploymentAdoptionGoReport extends IServiceDeploymentAdoptionReportBase {
+    decision: 'GO';
+    service: IServiceDeploymentAdoptionServiceSnapshot & {
+        deployOnPush: true;
+        immutableImageRequired: false;
+    };
+    registry: IServiceDeploymentAdoptionRegistrySnapshot & {
+        tag: string;
+        digest: TSha256Digest;
+        mediaType: 'application/vnd.oci.image.index.v1+json' | 'application/vnd.docker.distribution.manifest.list.v2+json';
+        platforms: [IOciPlatformDescriptorSummary, ...IOciPlatformDescriptorSummary[]];
+        releaseId: string;
+        releaseTag: string;
+    };
+    runtimeTasks: [IDeploymentPreflightRuntimeTask, ...IDeploymentPreflightRuntimeTask[]];
+    targetScope: IImmutableImageTargetScope;
+    adoptionDigest: TServiceDeploymentAdoptionDigest;
+    blockers: [];
+}
+export interface IServiceDeploymentAdoptionNoGoReport extends IServiceDeploymentAdoptionReportBase {
+    decision: 'NO-GO';
+    service?: IServiceDeploymentAdoptionServiceSnapshot;
+    registry: IServiceDeploymentAdoptionRegistrySnapshot;
+    runtimeTasks: IDeploymentPreflightRuntimeTask[];
+    targetScope?: IImmutableImageTargetScope;
+    adoptionDigest?: never;
+    blockers: [IServiceDeploymentAdoptionBlocker, ...IServiceDeploymentAdoptionBlocker[]];
+}
+export type IServiceDeploymentAdoptionReport = IServiceDeploymentAdoptionGoReport | IServiceDeploymentAdoptionNoGoReport;
+export interface IServiceDeploymentAdoptionResult {
+    adoptionId: string;
+    adoptionDigest: TServiceDeploymentAdoptionDigest;
+    idempotentReplay: boolean;
+    plan: IImmutableImageDeploymentPlan;
+}
+export declare const validateServiceDeploymentAdoptionPreflightInput: (inputArg: unknown) => string[];
+export declare const validateServiceDeploymentAdoptionInput: (inputArg: unknown) => string[];
+export declare const validateServiceDeploymentAdoptionReport: (reportArg: unknown) => string[];
+export {};

package/dist_ts/data/deploymentadoption.js

@@ -0,0 +1,303 @@
+import { normalizeImmutableReleaseTag, normalizeSha256Digest } from './immutableimage.js';
+const boundaryIdentifierRegex = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,199}$/;
+const indexMediaTypes = new Set([
+    'application/vnd.oci.image.index.v1+json',
+    'application/vnd.docker.distribution.manifest.list.v2+json',
+]);
+const adoptionBlockerCodes = new Set([
+    'INVALID_REQUEST',
+    'AUTHORIZATION_MISSING',
+    'SERVICE_NOT_FOUND',
+    'SERVICE_OWNERSHIP_MISMATCH',
+    'SERVICE_ALREADY_IMMUTABLE',
+    'SERVICE_STATE_CONFLICT',
+    'REGISTRY_TARGET_MISSING',
+    'REGISTRY_REFERENCE_INVALID',
+    'REGISTRY_DIGEST_MISSING',
+    'OCI_INDEX_REQUIRED',
+    'OCI_PLATFORM_MISSING',
+    'RELEASE_NOT_FOUND',
+    'RELEASE_TAG_AMBIGUOUS',
+    'TARGET_SCOPE_UNAVAILABLE',
+    'RUNTIME_ATTESTATION_INCOMPLETE',
+    'RUNTIME_DIGEST_MISMATCH',
+]);
+const isRecord = (valueArg) => Boolean(valueArg) && typeof valueArg === 'object' && !Array.isArray(valueArg);
+const isBoundedIdentifier = (valueArg) => typeof valueArg === 'string' && boundaryIdentifierRegex.test(valueArg);
+const isCanonicalDigest = (valueArg) => Boolean(normalizeSha256Digest(valueArg)) && normalizeSha256Digest(valueArg) === valueArg;
+const isNonNegativeInteger = (valueArg) => Number.isSafeInteger(valueArg) && valueArg >= 0;
+export const validateServiceDeploymentAdoptionPreflightInput = (inputArg) => {
+    if (!isRecord(inputArg))
+        return ['adoption preflight input must be an object'];
+    const errors = [];
+    if (!isBoundedIdentifier(inputArg.requestId)) {
+        errors.push('requestId must be a bounded canonical identifier');
+    }
+    for (const key of ['organizationId', 'serviceId']) {
+        if (!isBoundedIdentifier(inputArg[key])) {
+            errors.push(`${key} must be a bounded canonical identifier`);
+        }
+    }
+    return errors;
+};
+export const validateServiceDeploymentAdoptionInput = (inputArg) => {
+    const errors = validateServiceDeploymentAdoptionPreflightInput(inputArg);
+    if (!isRecord(inputArg))
+        return errors;
+    if (!isBoundedIdentifier(inputArg.idempotencyKey)) {
+        errors.push('idempotencyKey must be a bounded canonical identifier');
+    }
+    if (!isCanonicalDigest(inputArg.expectedAdoptionDigest)) {
+        errors.push('expectedAdoptionDigest must be a canonical sha256 digest');
+    }
+    return errors;
+};
+export const validateServiceDeploymentAdoptionReport = (reportArg) => {
+    if (!isRecord(reportArg))
+        return ['adoption report must be an object'];
+    const errors = [];
+    if (reportArg.schemaVersion !== 1)
+        errors.push('schemaVersion must be 1');
+    if (reportArg.mutationPerformed !== false) {
+        errors.push('adoption preflight must be mutation-free');
+    }
+    if (!isBoundedIdentifier(reportArg.requestId)) {
+        errors.push('requestId must be a bounded canonical identifier');
+    }
+    if (!isNonNegativeInteger(reportArg.generatedAt)) {
+        errors.push('generatedAt must be a non-negative integer');
+    }
+    if (reportArg.decision !== 'GO' && reportArg.decision !== 'NO-GO') {
+        errors.push('decision must be GO or NO-GO');
+    }
+    const attestation = reportArg.runtimeAttestation;
+    if (!isRecord(attestation)) {
+        errors.push('runtimeAttestation must be an object');
+    }
+    else {
+        for (const key of [
+            'requiredReplicaCount',
+            'observedReplicaCount',
+            'healthyReplicaCount',
+            'observedDigestReplicaCount',
+        ]) {
+            if (!isNonNegativeInteger(attestation[key])) {
+                errors.push(`runtimeAttestation.${key} must be a non-negative integer`);
+            }
+        }
+        if (typeof attestation.observedDigestConsistent !== 'boolean') {
+            errors.push('runtimeAttestation.observedDigestConsistent must be boolean');
+        }
+    }
+    const blockers = reportArg.blockers;
+    if (!Array.isArray(blockers)) {
+        errors.push('blockers must be an array');
+    }
+    else {
+        for (const blocker of blockers) {
+            if (!isRecord(blocker)
+                || !adoptionBlockerCodes.has(blocker.code)
+                || typeof blocker.message !== 'string'
+                || !blocker.message.trim()) {
+                errors.push('each blocker must contain a supported code and non-empty message');
+                break;
+            }
+        }
+    }
+    if (reportArg.decision === 'NO-GO') {
+        if (Array.isArray(blockers) && blockers.length === 0) {
+            errors.push('a NO-GO report must contain at least one blocker');
+        }
+        if (reportArg.adoptionDigest !== undefined) {
+            errors.push('a NO-GO report must not contain an adoption digest');
+        }
+        return errors;
+    }
+    if (reportArg.decision !== 'GO')
+        return errors;
+    if (Array.isArray(blockers) && blockers.length !== 0) {
+        errors.push('a GO report must not contain blockers');
+    }
+    if (!isCanonicalDigest(reportArg.adoptionDigest)) {
+        errors.push('a GO report requires a canonical adoption digest');
+    }
+    const service = reportArg.service;
+    const registry = reportArg.registry;
+    const targetScope = reportArg.targetScope;
+    const runtimeTasks = reportArg.runtimeTasks;
+    if (!isRecord(service)) {
+        errors.push('a GO report requires a service snapshot');
+    }
+    else {
+        for (const key of ['organizationId', 'serviceId', 'serviceName', 'imageId']) {
+            if (!isBoundedIdentifier(service[key]))
+                errors.push(`service.${key} is invalid`);
+        }
+        if (service.deployOnPush !== true || service.immutableImageRequired !== false) {
+            errors.push('a GO report requires the legacy mutable service state');
+        }
+        if (typeof service.configuredReference !== 'string' || !service.configuredReference.trim()) {
+            errors.push('service.configuredReference must be non-empty');
+        }
+        if (!isRecord(service.registryTarget)) {
+            errors.push('service.registryTarget must be present');
+        }
+    }
+    let registryDigest;
+    if (!isRecord(registry)) {
+        errors.push('a GO report requires a registry snapshot');
+    }
+    else {
+        if (!normalizeImmutableReleaseTag(registry.tag) || registry.tag !== registry.releaseTag) {
+            errors.push('registry tag and releaseTag must be the same immutable tag');
+        }
+        if (!isCanonicalDigest(registry.digest)) {
+            errors.push('registry.digest must be a canonical sha256 digest');
+        }
+        else {
+            registryDigest = registry.digest;
+            if (reportArg.adoptionDigest === registry.digest) {
+                errors.push('adoption digest must be a distinct full-state fence, not the image digest');
+            }
+        }
+        if (!indexMediaTypes.has(registry.mediaType)) {
+            errors.push('registry.mediaType must identify an OCI image index');
+        }
+        if (!isBoundedIdentifier(registry.releaseId)) {
+            errors.push('registry.releaseId must be a bounded canonical identifier');
+        }
+        if (!Array.isArray(registry.platforms) || registry.platforms.length === 0) {
+            errors.push('registry.platforms must contain OCI platform evidence');
+        }
+        else {
+            for (const architecture of ['amd64', 'arm64']) {
+                if (!registry.platforms.some((platformArg) => isRecord(platformArg)
+                    && platformArg.os === 'linux'
+                    && platformArg.architecture === architecture
+                    && platformArg.runnable === true
+                    && platformArg.manifestPresent === true
+                    && isCanonicalDigest(platformArg.digest))) {
+                    errors.push(`registry.platforms must contain runnable linux/${architecture} evidence`);
+                }
+            }
+        }
+    }
+    let requiredReplicaCount;
+    let targetNodeNames = [];
+    let replicasPerNode;
+    if (!isRecord(targetScope)) {
+        errors.push('a GO report requires an immutable target scope');
+    }
+    else {
+        const clusterIds = targetScope.targetClusterIds;
+        const nodeNames = targetScope.targetNodeNames;
+        replicasPerNode = targetScope.replicasPerNode;
+        requiredReplicaCount = targetScope.requiredReplicaCount;
+        if (!Array.isArray(clusterIds) || clusterIds.length !== 1
+            || clusterIds.some((valueArg) => !isBoundedIdentifier(valueArg))
+            || new Set(clusterIds).size !== clusterIds.length) {
+            errors.push('targetScope.targetClusterIds must identify exactly one attested cluster');
+        }
+        if (!Array.isArray(nodeNames) || nodeNames.length === 0
+            || nodeNames.some((valueArg) => !isBoundedIdentifier(valueArg))
+            || new Set(nodeNames).size !== nodeNames.length) {
+            errors.push('targetScope.targetNodeNames must be non-empty and unique');
+        }
+        else {
+            targetNodeNames = nodeNames;
+        }
+        if (!Number.isSafeInteger(replicasPerNode) || replicasPerNode < 1) {
+            errors.push('targetScope.replicasPerNode must be a positive integer');
+        }
+        if (!Number.isSafeInteger(requiredReplicaCount) || requiredReplicaCount < 1
+            || requiredReplicaCount !== targetNodeNames.length * (replicasPerNode || 0)) {
+            errors.push('targetScope.requiredReplicaCount must match nodes times replicas');
+        }
+    }
+    if (!Array.isArray(runtimeTasks) || runtimeTasks.length === 0) {
+        errors.push('a GO report requires runtime task evidence');
+    }
+    else {
+        if (requiredReplicaCount !== undefined && runtimeTasks.length !== requiredReplicaCount) {
+            errors.push('runtime task count must equal the required replica count');
+        }
+        const deploymentIds = new Set();
+        const taskCountsByNode = new Map();
+        for (const task of runtimeTasks) {
+            if (!isRecord(task)
+                || !isBoundedIdentifier(task.deploymentId)
+                || deploymentIds.has(task.deploymentId)) {
+                errors.push('runtime task deployment IDs must be valid and unique');
+                continue;
+            }
+            deploymentIds.add(task.deploymentId);
+            if (!isBoundedIdentifier(task.nodeName) || !targetNodeNames.includes(task.nodeName)) {
+                errors.push('every runtime task must belong to the exact target node scope');
+            }
+            else {
+                taskCountsByNode.set(task.nodeName, (taskCountsByNode.get(task.nodeName) || 0) + 1);
+            }
+            if (task.status !== 'running' || task.healthStatus !== 'healthy') {
+                errors.push('every runtime task must be running and healthy');
+            }
+            if (!registryDigest || task.observedDigest !== registryDigest) {
+                errors.push('every runtime task must attest the exact registry digest');
+            }
+            if (typeof task.imageReference !== 'string' || !task.imageReference.trim()) {
+                errors.push('every runtime task must identify its image reference');
+            }
+        }
+        if (replicasPerNode !== undefined
+            && targetNodeNames.some((nodeNameArg) => taskCountsByNode.get(nodeNameArg) !== replicasPerNode)) {
+            errors.push('runtime task evidence must cover every target node and replica');
+        }
+    }
+    if (isRecord(attestation) && requiredReplicaCount !== undefined) {
+        if (attestation.requiredReplicaCount !== requiredReplicaCount
+            || attestation.observedReplicaCount !== requiredReplicaCount
+            || attestation.healthyReplicaCount !== requiredReplicaCount
+            || attestation.observedDigestReplicaCount !== requiredReplicaCount
+            || attestation.observedDigestConsistent !== true) {
+            errors.push('runtime attestation must consistently cover every required replica');
+        }
+    }
+    if (isRecord(service) && isRecord(service.registryTarget) && isRecord(registry)) {
+        const target = service.registryTarget;
+        if (target.protocol !== 'oci'
+            || target.tag !== registry.tag
+            || target.serviceId !== service.serviceId
+            || target.imageId !== service.imageId
+            || typeof target.registryHost !== 'string'
+            || !target.registryHost
+            || typeof target.repository !== 'string'
+            || !target.repository
+            || target.imageUrl !== `${target.registryHost}/${target.repository}:${target.tag}`) {
+            errors.push('service registry target must exactly bind the adopted service, image, and tag');
+        }
+        if (registryDigest) {
+            const digestPinnedReference = `${target.registryHost}/${target.repository}@${registryDigest}`;
+            const tagAndDigestReference = `${target.imageUrl}@${registryDigest}`;
+            const configuredReferences = new Set([
+                target.tag,
+                target.imageUrl,
+                digestPinnedReference,
+                tagAndDigestReference,
+            ]);
+            if (!configuredReferences.has(service.configuredReference)) {
+                errors.push('service configured reference must exactly bind the adopted registry target');
+            }
+            const runtimeReferences = new Set([
+                target.imageUrl,
+                digestPinnedReference,
+                tagAndDigestReference,
+            ]);
+            if (Array.isArray(runtimeTasks)
+                && runtimeTasks.some((taskArg) => !isRecord(taskArg)
+                    || !runtimeReferences.has(taskArg.imageReference))) {
+                errors.push('every runtime task image reference must exactly bind the adopted registry target');
+            }
+        }
+    }
+    return errors;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploymentadoption.js","sourceRoot":"","sources":["../../ts/data/deploymentadoption.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/deploymentoperation.d.ts

@@ -0,0 +1,161 @@
+import type { IDeploymentPreflightProposedConfiguration, IDeploymentPreflightRuntimeTask } from './deploymentpreflight.js';
+import type { IImageRolloutStatus, IImmutableImageDeploymentPlan, TSha256Digest } from './immutableimage.js';
+import type { IRegistryTarget } from './registry.js';
+import type { TServiceTargetPortRef } from './serviceports.js';
+export type TDeploymentOperationMode = 'existing-service' | 'greenfield';
+export type TDeploymentOperationPhase = 'reserve' | 'promote' | 'route';
+interface IDeploymentReservationInputBase {
+    organizationId: string;
+    serviceId: string;
+    idempotencyKey: string;
+    sourceRevision: string;
+    version: string;
+    intentDigest: TSha256Digest;
+    proposedConfiguration: IDeploymentPreflightProposedConfiguration;
+    releaseTag: string;
+    routes: IDeploymentRouteRequest[];
+}
+export interface IExistingServiceDeploymentReservationInput extends IDeploymentReservationInputBase {
+    mode: 'existing-service';
+    expectedRolloutGeneration: number;
+    expectedCurrentRolloutId?: string;
+}
+export interface IGreenfieldServiceDeploymentReservationInput extends IDeploymentReservationInputBase {
+    mode: 'greenfield';
+    expectedRolloutGeneration?: never;
+    expectedCurrentRolloutId?: never;
+}
+export type IDeploymentReservationInput = IExistingServiceDeploymentReservationInput | IGreenfieldServiceDeploymentReservationInput;
+export type TDeploymentOperationState = 'reserving' | 'reserved' | 'provisioning' | 'awaiting-image' | 'image-recorded' | 'promoting-image' | 'rolling-out' | 'ready-for-route' | 'promoting-route' | 'verifying-route' | 'succeeded' | 'rolling-back' | 'rolled-back' | 'failed' | 'cleaning' | 'cleaned';
+export interface IDeploymentRouteRequest {
+    hostname: string;
+    targetPort: Extract<TServiceTargetPortRef, number>;
+    /** Required exact one-label hostname used to verify a wildcard route. */
+    verificationHostname?: string;
+    readinessPath?: string;
+    expectedStatusCodes?: number[];
+}
+export interface IDeploymentRouteClaimTarget {
+    hostname: string;
+    bucketHostname: string;
+    wildcard: boolean;
+}
+export declare const canonicalizeDeploymentHostname: (hostnameArg: unknown) => string | undefined;
+/**
+ * Wildcards match exactly one label. Exact siblings share a bucket document
+ * but may coexist; a wildcard claim excludes every exact name in its bucket.
+ */
+export declare const getDeploymentRouteClaimTarget: (hostnameArg: string) => IDeploymentRouteClaimTarget | undefined;
+export declare const getDeploymentRouteVerificationHostname: (routeArg: IDeploymentRouteRequest) => string | undefined;
+export declare const normalizeDeploymentReadinessPath: (pathArg?: unknown) => string | undefined;
+export declare const validateDeploymentProposedConfiguration: (configurationArg: unknown) => string[];
+export declare const validateDeploymentReservationInput: (inputArg: unknown) => string[];
+interface IDeploymentRouteVerificationEvidenceBase {
+    hostname: string;
+    url: string;
+    checkedAt: number;
+    resolvedAddresses: string[];
+    rolloutId: string;
+    rolloutGeneration: number;
+    expectedDigest: TSha256Digest;
+}
+export interface IDeploymentRouteVerificationSuccessEvidence extends IDeploymentRouteVerificationEvidenceBase {
+    outcome: 'succeeded';
+    tls: {
+        authorized: true;
+        servername: string;
+        subjectAlternativeNames: string[];
+        validFrom?: string;
+        validTo?: string;
+    };
+    http: {
+        statusCode: number;
+        redirected: false;
+    };
+    readiness: {
+        path: string;
+        expectedStatusCodes: number[];
+        ready: true;
+    };
+}
+export interface IDeploymentRouteVerificationFailureEvidence extends IDeploymentRouteVerificationEvidenceBase {
+    outcome: 'failed';
+    stage: 'dns' | 'address-policy' | 'connect' | 'tls' | 'http' | 'readiness';
+    code: string;
+    message: string;
+    tls?: IDeploymentRouteVerificationSuccessEvidence['tls'];
+    http?: IDeploymentRouteVerificationSuccessEvidence['http'];
+    readiness?: IDeploymentRouteVerificationSuccessEvidence['readiness'];
+}
+export type IDeploymentRouteVerificationEvidence = IDeploymentRouteVerificationSuccessEvidence | IDeploymentRouteVerificationFailureEvidence;
+export interface IDeploymentOperationFailure {
+    code: string;
+    message: string;
+    retryable: boolean;
+    failedAt: number;
+}
+/**
+ * Durable deployment fence. All state transitions compare-and-set both id and
+ * revision. Claim keys are server-generated and never accepted as authority.
+ */
+export interface IServiceDeploymentOperation {
+    id: string;
+    revision: number;
+    data: {
+        mode: TDeploymentOperationMode;
+        organizationId: string;
+        serviceId: string;
+        actorUserId: string;
+        idempotencyKey: string;
+        requestDigest: TSha256Digest;
+        sourceRevision: string;
+        version: string;
+        intentDigest: TSha256Digest;
+        configurationDigest: TSha256Digest;
+        proposedConfiguration: IDeploymentPreflightProposedConfiguration;
+        namespace: string;
+        registryTarget: IRegistryTarget;
+        releaseTag: string;
+        routes: IDeploymentRouteRequest[];
+        claimKeys: string[];
+        state: TDeploymentOperationState;
+        releaseId?: string;
+        registryRootDigest?: TSha256Digest;
+        rolloutId?: string;
+        rolloutGeneration?: number;
+        routeGeneration?: number;
+        routeVerification?: IDeploymentRouteVerificationEvidence[];
+        failure?: IDeploymentOperationFailure;
+        createdAt: number;
+        updatedAt: number;
+    };
+}
+export interface IServiceDeploymentStatus {
+    operation: IServiceDeploymentOperation;
+    imageDeployment?: IImmutableImageDeploymentPlan;
+    imageRolloutStatus?: IImageRolloutStatus;
+    runtimeTasks: IDeploymentRuntimeTaskEvidence[];
+    routeVerification: IDeploymentRouteVerificationEvidence[];
+    immutableRolloutSucceeded: boolean;
+    runtimeDigestVerified: boolean;
+    routeVerified: boolean;
+    succeeded: boolean;
+}
+interface IDeploymentRuntimeTaskEvidenceBase extends Omit<IDeploymentPreflightRuntimeTask, 'verificationStatus' | 'observedDigest' | 'reportedDigest'> {
+    rolloutId: string;
+    rolloutGeneration: number;
+    expectedDigest: TSha256Digest;
+    observedAt: number;
+}
+export interface IVerifiedDeploymentRuntimeTaskEvidence extends IDeploymentRuntimeTaskEvidenceBase {
+    verificationStatus: 'verified';
+    observedDigest: TSha256Digest;
+    reportedDigest: TSha256Digest;
+}
+export interface IUnverifiedDeploymentRuntimeTaskEvidence extends IDeploymentRuntimeTaskEvidenceBase {
+    verificationStatus: 'missing' | 'mismatched';
+    observedDigest?: TSha256Digest;
+    reportedDigest?: TSha256Digest;
+}
+export type IDeploymentRuntimeTaskEvidence = IVerifiedDeploymentRuntimeTaskEvidence | IUnverifiedDeploymentRuntimeTaskEvidence;
+export {};