@vcp-dev/contracts 0.6.4 → 0.6.6

package/dist/template-upgrade-observability.d.ts

@@ -0,0 +1,137 @@
+import { z } from "zod";
+export declare const TemplateUpgradeOutcomeSchema: z.ZodEnum<{
+    paused: "paused";
+    blocked: "blocked";
+    validation_failed: "validation_failed";
+    eligible: "eligible";
+    fast_path: "fast_path";
+    upgraded: "upgraded";
+    skipped: "skipped";
+    lock_skipped: "lock_skipped";
+    cas_aborted: "cas_aborted";
+}>;
+export type TemplateUpgradeOutcome = z.infer<typeof TemplateUpgradeOutcomeSchema>;
+export declare const TemplateUpgradeValidationStageSchema: z.ZodEnum<{
+    typecheck: "typecheck";
+    build: "build";
+    health: "health";
+    validation: "validation";
+}>;
+export type TemplateUpgradeValidationStage = z.infer<typeof TemplateUpgradeValidationStageSchema>;
+export declare const TemplateUpgradeCasOutcomeSchema: z.ZodEnum<{
+    not_attempted: "not_attempted";
+    promoted: "promoted";
+    aborted: "aborted";
+}>;
+export type TemplateUpgradeCasOutcome = z.infer<typeof TemplateUpgradeCasOutcomeSchema>;
+export declare const RecordTemplateUpgradeEventRequestSchema: z.ZodObject<{
+    template_id: z.ZodString;
+    from_version: z.ZodNullable<z.ZodString>;
+    to_version: z.ZodString;
+    outcome: z.ZodEnum<{
+        paused: "paused";
+        blocked: "blocked";
+        validation_failed: "validation_failed";
+        eligible: "eligible";
+        fast_path: "fast_path";
+        upgraded: "upgraded";
+        skipped: "skipped";
+        lock_skipped: "lock_skipped";
+        cas_aborted: "cas_aborted";
+    }>;
+    attempt: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+    replaced_group_count: z.ZodNumber;
+    skipped_group_count: z.ZodNumber;
+    validation_stage: z.ZodNullable<z.ZodEnum<{
+        typecheck: "typecheck";
+        build: "build";
+        health: "health";
+        validation: "validation";
+    }>>;
+    cas_outcome: z.ZodNullable<z.ZodEnum<{
+        not_attempted: "not_attempted";
+        promoted: "promoted";
+        aborted: "aborted";
+    }>>;
+}, z.core.$strict>;
+export type RecordTemplateUpgradeEventRequest = z.infer<typeof RecordTemplateUpgradeEventRequestSchema>;
+export declare const RecordTemplateUpgradeEventResponseSchema: z.ZodObject<{
+    recorded: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type RecordTemplateUpgradeEventResponse = z.infer<typeof RecordTemplateUpgradeEventResponseSchema>;
+export declare const GetTemplateUpgradeReportQuerySchema: z.ZodObject<{
+    from: z.ZodISODateTime;
+    to: z.ZodISODateTime;
+}, z.core.$strict>;
+export type GetTemplateUpgradeReportQuery = z.infer<typeof GetTemplateUpgradeReportQuerySchema>;
+export declare const TemplateUpgradeOutcomeCountsSchema: z.ZodObject<{
+    eligible: z.ZodNumber;
+    fast_path: z.ZodNumber;
+    upgraded: z.ZodNumber;
+    skipped: z.ZodNumber;
+    lock_skipped: z.ZodNumber;
+    cas_aborted: z.ZodNumber;
+    validation_failed: z.ZodNumber;
+    blocked: z.ZodNumber;
+    paused: z.ZodNumber;
+}, z.core.$strict>;
+export type TemplateUpgradeOutcomeCounts = z.infer<typeof TemplateUpgradeOutcomeCountsSchema>;
+export declare const GetTemplateUpgradeReportResponseSchema: z.ZodObject<{
+    window: z.ZodObject<{
+        from: z.ZodISODateTime;
+        to: z.ZodISODateTime;
+    }, z.core.$strict>;
+    outcome_counts: z.ZodObject<{
+        eligible: z.ZodNumber;
+        fast_path: z.ZodNumber;
+        upgraded: z.ZodNumber;
+        skipped: z.ZodNumber;
+        lock_skipped: z.ZodNumber;
+        cas_aborted: z.ZodNumber;
+        validation_failed: z.ZodNumber;
+        blocked: z.ZodNumber;
+        paused: z.ZodNumber;
+    }, z.core.$strict>;
+    current_state_counts: z.ZodObject<{
+        blocked: z.ZodNumber;
+        paused: z.ZodNumber;
+    }, z.core.$strict>;
+    duration_ms: z.ZodObject<{
+        p50: z.ZodNullable<z.ZodNumber>;
+        p95: z.ZodNullable<z.ZodNumber>;
+        sample_count: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type GetTemplateUpgradeReportResponse = z.infer<typeof GetTemplateUpgradeReportResponseSchema>;
+export declare const ListTemplateUpgradeSnapshotDeletionCandidatesQuerySchema: z.ZodObject<{
+    older_than: z.ZodISODateTime;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    include_candidates: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "true" | "false">>;
+}, z.core.$strict>;
+export type ListTemplateUpgradeSnapshotDeletionCandidatesQuery = z.input<typeof ListTemplateUpgradeSnapshotDeletionCandidatesQuerySchema>;
+export declare const TemplateUpgradeSnapshotDeletionCandidateSchema: z.ZodObject<{
+    site_id: z.ZodString;
+    snapshot_id: z.ZodString;
+    status: z.ZodEnum<{
+        candidate: "candidate";
+        deleting: "deleting";
+    }>;
+    created_at: z.ZodISODateTime;
+}, z.core.$strict>;
+export type TemplateUpgradeSnapshotDeletionCandidate = z.infer<typeof TemplateUpgradeSnapshotDeletionCandidateSchema>;
+export declare const ListTemplateUpgradeSnapshotDeletionCandidatesResponseSchema: z.ZodObject<{
+    snapshots: z.ZodArray<z.ZodObject<{
+        site_id: z.ZodString;
+        snapshot_id: z.ZodString;
+        status: z.ZodEnum<{
+            candidate: "candidate";
+            deleting: "deleting";
+        }>;
+        created_at: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ListTemplateUpgradeSnapshotDeletionCandidatesResponse = z.infer<typeof ListTemplateUpgradeSnapshotDeletionCandidatesResponseSchema>;

package/dist/template-upgrade-state.d.ts

@@ -0,0 +1,193 @@
+import { z } from "zod";
+export declare const TemplateUpgradeStatusSchema: z.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    blocked: "blocked";
+}>;
+export type TemplateUpgradeStatus = z.infer<typeof TemplateUpgradeStatusSchema>;
+export declare const TemplateUpgradeErrorCodeSchema: z.ZodEnum<{
+    typecheck_failed: "typecheck_failed";
+    health_failed: "health_failed";
+    validation_failed: "validation_failed";
+}>;
+export type TemplateUpgradeErrorCode = z.infer<typeof TemplateUpgradeErrorCodeSchema>;
+export declare const TemplateUpgradeStateSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+        blocked: "blocked";
+    }>;
+    attempts: z.ZodNumber;
+    attempted_template_version: z.ZodNullable<z.ZodString>;
+    last_error_code: z.ZodNullable<z.ZodEnum<{
+        typecheck_failed: "typecheck_failed";
+        health_failed: "health_failed";
+        validation_failed: "validation_failed";
+    }>>;
+}, z.core.$strict>;
+export type TemplateUpgradeState = z.infer<typeof TemplateUpgradeStateSchema>;
+export declare const PrepareTemplateUpgradeStateRequestSchema: z.ZodObject<{
+    template_id: z.ZodString;
+    target_template_version: z.ZodString;
+}, z.core.$strict>;
+export type PrepareTemplateUpgradeStateRequest = z.infer<typeof PrepareTemplateUpgradeStateRequestSchema>;
+export declare const PrepareTemplateUpgradeStateResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"proceed">;
+    state: z.ZodObject<{
+        attempts: z.ZodNumber;
+        attempted_template_version: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            typecheck_failed: "typecheck_failed";
+            health_failed: "health_failed";
+            validation_failed: "validation_failed";
+        }>>;
+        status: z.ZodLiteral<"active">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"skip_not_newer">;
+    state: z.ZodObject<{
+        attempts: z.ZodNumber;
+        attempted_template_version: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            typecheck_failed: "typecheck_failed";
+            health_failed: "health_failed";
+            validation_failed: "validation_failed";
+        }>>;
+        status: z.ZodLiteral<"active">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"skip_paused">;
+    state: z.ZodObject<{
+        attempts: z.ZodNumber;
+        attempted_template_version: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            typecheck_failed: "typecheck_failed";
+            health_failed: "health_failed";
+            validation_failed: "validation_failed";
+        }>>;
+        status: z.ZodLiteral<"paused">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"skip_blocked">;
+    state: z.ZodObject<{
+        attempts: z.ZodNumber;
+        attempted_template_version: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            typecheck_failed: "typecheck_failed";
+            health_failed: "health_failed";
+            validation_failed: "validation_failed";
+        }>>;
+        status: z.ZodLiteral<"blocked">;
+    }, z.core.$strict>;
+}, z.core.$strict>], "action">;
+export type PrepareTemplateUpgradeStateResponse = z.infer<typeof PrepareTemplateUpgradeStateResponseSchema>;
+/**
+ * Read-only projection of the persisted state for a target version. The query
+ * and response deliberately match prepare's bounded target/action contract;
+ * only the API method differs, so callers cannot supply tenant identity or raw
+ * validation data.
+ */
+export declare const InspectTemplateUpgradeStateRequestSchema: z.ZodObject<{
+    template_id: z.ZodString;
+    target_template_version: z.ZodString;
+}, z.core.$strict>;
+export type InspectTemplateUpgradeStateRequest = z.infer<typeof InspectTemplateUpgradeStateRequestSchema>;
+export declare const InspectTemplateUpgradeStateResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"proceed">;
+    state: z.ZodObject<{
+        attempts: z.ZodNumber;
+        attempted_template_version: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            typecheck_failed: "typecheck_failed";
+            health_failed: "health_failed";
+            validation_failed: "validation_failed";
+        }>>;
+        status: z.ZodLiteral<"active">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"skip_not_newer">;
+    state: z.ZodObject<{
+        attempts: z.ZodNumber;
+        attempted_template_version: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            typecheck_failed: "typecheck_failed";
+            health_failed: "health_failed";
+            validation_failed: "validation_failed";
+        }>>;
+        status: z.ZodLiteral<"active">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"skip_paused">;
+    state: z.ZodObject<{
+        attempts: z.ZodNumber;
+        attempted_template_version: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            typecheck_failed: "typecheck_failed";
+            health_failed: "health_failed";
+            validation_failed: "validation_failed";
+        }>>;
+        status: z.ZodLiteral<"paused">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"skip_blocked">;
+    state: z.ZodObject<{
+        attempts: z.ZodNumber;
+        attempted_template_version: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            typecheck_failed: "typecheck_failed";
+            health_failed: "health_failed";
+            validation_failed: "validation_failed";
+        }>>;
+        status: z.ZodLiteral<"blocked">;
+    }, z.core.$strict>;
+}, z.core.$strict>], "action">;
+export type InspectTemplateUpgradeStateResponse = z.infer<typeof InspectTemplateUpgradeStateResponseSchema>;
+export declare const RecordTemplateUpgradeFailureRequestSchema: z.ZodObject<{
+    template_id: z.ZodString;
+    target_template_version: z.ZodString;
+    error_code: z.ZodEnum<{
+        typecheck_failed: "typecheck_failed";
+        health_failed: "health_failed";
+        validation_failed: "validation_failed";
+    }>;
+}, z.core.$strict>;
+export type RecordTemplateUpgradeFailureRequest = z.infer<typeof RecordTemplateUpgradeFailureRequestSchema>;
+export declare const RecordTemplateUpgradeFailureResponseSchema: z.ZodObject<{
+    state: z.ZodObject<{
+        status: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+            blocked: "blocked";
+        }>;
+        attempts: z.ZodNumber;
+        attempted_template_version: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            typecheck_failed: "typecheck_failed";
+            health_failed: "health_failed";
+            validation_failed: "validation_failed";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RecordTemplateUpgradeFailureResponse = z.infer<typeof RecordTemplateUpgradeFailureResponseSchema>;
+export declare const RecordTemplateUpgradeSuccessRequestSchema: z.ZodObject<{
+    template_id: z.ZodString;
+    target_template_version: z.ZodString;
+}, z.core.$strict>;
+export type RecordTemplateUpgradeSuccessRequest = z.infer<typeof RecordTemplateUpgradeSuccessRequestSchema>;
+export declare const RecordTemplateUpgradeSuccessResponseSchema: z.ZodObject<{
+    state: z.ZodObject<{
+        status: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+            blocked: "blocked";
+        }>;
+        attempts: z.ZodNumber;
+        attempted_template_version: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            typecheck_failed: "typecheck_failed";
+            health_failed: "health_failed";
+            validation_failed: "validation_failed";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RecordTemplateUpgradeSuccessResponse = z.infer<typeof RecordTemplateUpgradeSuccessResponseSchema>;

package/dist/template-version.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const TemplateVersionSchema: z.ZodString;
+export type TemplateVersion = z.infer<typeof TemplateVersionSchema>;
+export type TemplateVersionComparison = -1 | 0 | 1;
+export declare function compareTemplateVersions(left: unknown, right: unknown): TemplateVersionComparison | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcp-dev/contracts",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {