@opensoha/contracts 0.1.11 → 0.1.13

package/compat/json-schema-ecosystem-0.1.0.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.11",
+  "version": "0.1.13",
   "schemas": {
     "plugins/plugin-manifest.schema.json": {
       "rootRequired": ["id", "name", "publisher", "type", "version"],

package/compat/openapi-loose-boundaries-0.1.0.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.11",
+  "version": "0.1.13",
   "generatedFrom": "openapi/soha-api.yaml",
   "entries": [
     {

package/fixtures/openapi/DockerHostAgentCredentialsEnvelope/invalid/missing-runtime-token.json

@@ -0,0 +1,9 @@
+{
+  "data": {
+    "hostId": "runtime-host-01",
+    "operationId": "host-sync-01",
+    "agentId": "docker-agent-01",
+    "agentBearerToken": "agent-secret-012345678901234567890",
+    "issuedAt": "2026-08-14T10:15:00Z"
+  }
+}

package/fixtures/openapi/DockerHostAgentCredentialsEnvelope/valid/credentials.json

@@ -0,0 +1,10 @@
+{
+  "data": {
+    "hostId": "runtime-host-01",
+    "operationId": "host-sync-01",
+    "agentId": "docker-agent-01",
+    "agentBearerToken": "agent-secret-012345678901234567890",
+    "runtimeBearerToken": "runtime-secret-012345678901234567",
+    "issuedAt": "2026-08-14T10:15:00Z"
+  }
+}

package/fixtures/openapi/DockerHostAgentEnrollmentRequest/invalid/short-token.json

@@ -0,0 +1,4 @@
+{
+  "agentId": "docker-agent-01",
+  "enrollmentToken": "too-short"
+}

package/fixtures/openapi/DockerHostAgentEnrollmentRequest/valid/enrollment.json

@@ -0,0 +1,4 @@
+{
+  "agentId": "docker-agent-01",
+  "enrollmentToken": "enrollment-secret-0123456789012345"
+}

package/fixtures/openapi/KubernetesWorkloadSnapshotEnvelope/invalid/missing-content.json

@@ -0,0 +1,8 @@
+{
+  "data": {
+    "sourceUid": "a17fd246-9f85-4a1f-8bb0-c6c1f844b17e",
+    "selectedContainer": "worker",
+    "containers": [],
+    "warnings": []
+  }
+}

package/fixtures/openapi/KubernetesWorkloadSnapshotEnvelope/valid/job.json

@@ -0,0 +1,14 @@
+{
+  "data": {
+    "content": "apiVersion: batch/v1\nkind: Job\nmetadata:\n  name: report\n",
+    "sourceUid": "a17fd246-9f85-4a1f-8bb0-c6c1f844b17e",
+    "selectedContainer": "worker",
+    "containers": [
+      {
+        "name": "worker",
+        "image": "registry.example.com/report:2026.08"
+      }
+    ],
+    "warnings": []
+  }
+}

package/fixtures/openapi/KubernetesWorkloadSnapshotRequest/invalid/cronjob-missing-schedule.json

@@ -0,0 +1,8 @@
+{
+  "namespace": "default",
+  "sourceKind": "Deployment",
+  "sourceName": "reports",
+  "targetKind": "CronJob",
+  "targetName": "reports-schedule",
+  "restartPolicy": "Never"
+}

package/fixtures/openapi/KubernetesWorkloadSnapshotRequest/invalid/workload-cronjob-missing-schedule.json

@@ -0,0 +1,8 @@
+{
+  "namespace": "default",
+  "sourceKind": "StatefulSet",
+  "sourceName": "indexer",
+  "targetKind": "WorkloadCronJob",
+  "targetName": "indexer-schedule",
+  "restartPolicy": "OnFailure"
+}

package/fixtures/openapi/KubernetesWorkloadSnapshotRequest/valid/cronjob.json

@@ -0,0 +1,9 @@
+{
+  "namespace": "default",
+  "sourceKind": "Deployment",
+  "sourceName": "reports",
+  "targetKind": "CronJob",
+  "targetName": "reports-schedule",
+  "restartPolicy": "Never",
+  "schedule": "0 * * * *"
+}

package/fixtures/openapi/KubernetesWorkloadSnapshotRequest/valid/job-zero-values.json

@@ -0,0 +1,11 @@
+{
+  "namespace": "default",
+  "sourceKind": "DaemonSet",
+  "sourceName": "collector",
+  "targetKind": "Job",
+  "targetName": "collector-once",
+  "restartPolicy": "Never",
+  "parallelism": 0,
+  "completions": 0,
+  "activeDeadlineSeconds": 0
+}

package/fixtures/openapi/KubernetesWorkloadSnapshotRequest/valid/workload-cronjob.json

@@ -0,0 +1,9 @@
+{
+  "namespace": "default",
+  "sourceKind": "StatefulSet",
+  "sourceName": "indexer",
+  "targetKind": "WorkloadCronJob",
+  "targetName": "indexer-schedule",
+  "restartPolicy": "OnFailure",
+  "schedule": "*/15 * * * *"
+}

package/gen/go/sohaapi/client.go

@@ -14,7 +14,7 @@ import (
 	"time"
 )
 
-const defaultUserAgent = "opensoha-contracts/0.1.11"
+const defaultUserAgent = "opensoha-contracts/0.1.13"
 
 type Client struct {
 	BaseURL    string
@@ -404,6 +404,15 @@ func (c *Client) ClaimDockerOperation(ctx context.Context, req DockerOperationCl
 	return out.Data, nil
 }
 
+func (c *Client) ExchangeDockerHostAgentEnrollment(ctx context.Context, operationID string, req DockerHostAgentEnrollmentRequest) (DockerHostAgentCredentials, error) {
+	var out DockerHostAgentCredentialsEnvelope
+	path := "/docker/agent-installations/" + url.PathEscape(strings.TrimSpace(operationID)) + "/enroll"
+	if err := c.doJSON(ctx, http.MethodPost, path, false, req, &out); err != nil {
+		return DockerHostAgentCredentials{}, err
+	}
+	return out.Data, nil
+}
+
 func (c *Client) GetDockerOperationRunnerStatus(ctx context.Context, operationID string) (DockerOperation, error) {
 	var out DockerOperationEnvelope
 	path := "/docker/operations/" + url.PathEscape(strings.TrimSpace(operationID)) + "/runner-status"

package/gen/go/sohaapi/client_test.go

@@ -143,6 +143,35 @@ func TestRunnerClaimClientsAcceptNoContent(t *testing.T) {
 	}
 }
 
+func TestExchangeDockerHostAgentEnrollmentIsPublicAndReturnsCredentials(t *testing.T) {
+	issuedAt := time.Now().UTC().Truncate(time.Second)
+	client := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
+		assertPublicRequest(t, r, http.MethodPost, "/api/v1/docker/agent-installations/operation-1/enroll")
+		request := decodeJSONRequestBody[DockerHostAgentEnrollmentRequest](t, r)
+		if request.AgentID != "host-1" || request.EnrollmentToken != "enrollment-secret-0123456789012345" {
+			t.Fatalf("enrollment request = %#v", request)
+		}
+		w.Header().Set("Cache-Control", "no-store")
+		w.WriteHeader(http.StatusCreated)
+		writeJSON(t, w, map[string]any{"data": map[string]any{
+			"hostId": "host-1", "operationId": "operation-1", "agentId": "host-1",
+			"agentBearerToken": "agent-secret-012345678901234567890",
+			"runtimeBearerToken": "runtime-secret-012345678901234567",
+			"issuedAt": issuedAt,
+		}})
+	})
+
+	credentials, err := client.ExchangeDockerHostAgentEnrollment(context.Background(), "operation-1", DockerHostAgentEnrollmentRequest{
+		AgentID: "host-1", EnrollmentToken: "enrollment-secret-0123456789012345",
+	})
+	if err != nil {
+		t.Fatalf("exchange enrollment: %v", err)
+	}
+	if credentials.HostID != "host-1" || credentials.OperationID != "operation-1" || credentials.RuntimeBearerToken == "" || credentials.AgentBearerToken == "" {
+		t.Fatalf("credentials = %#v", credentials)
+	}
+}
+
 func TestRedeemSecretLeaseSendsRunnerBindingHeaders(t *testing.T) {
 	client := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
 		assertCommonRequest(t, r, http.MethodPost, "/api/v1/runner/secret-leases/lease%2Fone/redeem")

package/gen/go/sohaapi/types.go

@@ -2713,6 +2713,66 @@ func (e KubernetesWorkloadImportInputWorkloadKind) Valid() bool {
 	}
 }
 
+// Defines values for KubernetesWorkloadSnapshotRestartPolicy.
+const (
+	KubernetesWorkloadSnapshotRestartPolicyNever     KubernetesWorkloadSnapshotRestartPolicy = "Never"
+	KubernetesWorkloadSnapshotRestartPolicyOnFailure KubernetesWorkloadSnapshotRestartPolicy = "OnFailure"
+)
+
+// Valid indicates whether the value is a known member of the KubernetesWorkloadSnapshotRestartPolicy enum.
+func (e KubernetesWorkloadSnapshotRestartPolicy) Valid() bool {
+	switch e {
+	case KubernetesWorkloadSnapshotRestartPolicyNever:
+		return true
+	case KubernetesWorkloadSnapshotRestartPolicyOnFailure:
+		return true
+	default:
+		return false
+	}
+}
+
+// Defines values for KubernetesWorkloadSnapshotSourceKind.
+const (
+	KubernetesWorkloadSnapshotSourceKindDaemonSet   KubernetesWorkloadSnapshotSourceKind = "DaemonSet"
+	KubernetesWorkloadSnapshotSourceKindDeployment  KubernetesWorkloadSnapshotSourceKind = "Deployment"
+	KubernetesWorkloadSnapshotSourceKindStatefulSet KubernetesWorkloadSnapshotSourceKind = "StatefulSet"
+)
+
+// Valid indicates whether the value is a known member of the KubernetesWorkloadSnapshotSourceKind enum.
+func (e KubernetesWorkloadSnapshotSourceKind) Valid() bool {
+	switch e {
+	case KubernetesWorkloadSnapshotSourceKindDaemonSet:
+		return true
+	case KubernetesWorkloadSnapshotSourceKindDeployment:
+		return true
+	case KubernetesWorkloadSnapshotSourceKindStatefulSet:
+		return true
+	default:
+		return false
+	}
+}
+
+// Defines values for KubernetesWorkloadSnapshotTargetKind.
+const (
+	KubernetesWorkloadSnapshotTargetKindCronJob         KubernetesWorkloadSnapshotTargetKind = "CronJob"
+	KubernetesWorkloadSnapshotTargetKindJob             KubernetesWorkloadSnapshotTargetKind = "Job"
+	KubernetesWorkloadSnapshotTargetKindWorkloadCronJob KubernetesWorkloadSnapshotTargetKind = "WorkloadCronJob"
+)
+
+// Valid indicates whether the value is a known member of the KubernetesWorkloadSnapshotTargetKind enum.
+func (e KubernetesWorkloadSnapshotTargetKind) Valid() bool {
+	switch e {
+	case KubernetesWorkloadSnapshotTargetKindCronJob:
+		return true
+	case KubernetesWorkloadSnapshotTargetKindJob:
+		return true
+	case KubernetesWorkloadSnapshotTargetKindWorkloadCronJob:
+		return true
+	default:
+		return false
+	}
+}
+
 // Defines values for LLMCallLogCacheStatus.
 const (
 	LLMCallLogCacheStatusBypass       LLMCallLogCacheStatus = "bypass"
@@ -9758,6 +9818,32 @@ type DockerGitBuildInput struct {
 	RepositoryURL  string `json:"repositoryUrl"`
 }
 
+// DockerHostAgentCredentials defines model for DockerHostAgentCredentials.
+type DockerHostAgentCredentials struct {
+	// AgentBearerToken Credential for the Agent's local HTTP API, returned only by the successful enrollment response.
+	AgentBearerToken string    `json:"agentBearerToken"`
+	AgentID          string    `json:"agentId"`
+	HostID           string    `json:"hostId"`
+	IssuedAt         time.Time `json:"issuedAt"`
+	OperationID      string    `json:"operationId"`
+
+	// RuntimeBearerToken Revocable credential restricted to Docker operations for this host.
+	RuntimeBearerToken string `json:"runtimeBearerToken"`
+}
+
+// DockerHostAgentCredentialsEnvelope defines model for DockerHostAgentCredentialsEnvelope.
+type DockerHostAgentCredentialsEnvelope struct {
+	Data DockerHostAgentCredentials `json:"data"`
+}
+
+// DockerHostAgentEnrollmentRequest defines model for DockerHostAgentEnrollmentRequest.
+type DockerHostAgentEnrollmentRequest struct {
+	AgentID string `json:"agentId"`
+
+	// EnrollmentToken Short-lived one-time secret delivered only inside the installer.
+	EnrollmentToken string `json:"enrollmentToken"`
+}
+
 // DockerHostAgentInstallation defines model for DockerHostAgentInstallation.
 type DockerHostAgentInstallation struct {
 	Command     string    `json:"command"`
@@ -13957,6 +14043,70 @@ type KubernetesWorkloadRelation struct {
 	Relation  string `json:"relation,omitempty"`
 }
 
+// KubernetesWorkloadSnapshot defines model for KubernetesWorkloadSnapshot.
+type KubernetesWorkloadSnapshot struct {
+	Containers []KubernetesWorkloadSnapshotContainer `json:"containers"`
+
+	// Content Generated native batch/v1 Job or CronJob YAML, or workloads.soha.io/v1alpha1 WorkloadCronJob YAML whose selected container image follows the source workload, ready for the existing resource-creation preflight.
+	Content           string   `json:"content"`
+	SelectedContainer string   `json:"selectedContainer"`
+	SourceUID         string   `json:"sourceUid"`
+	Warnings          []string `json:"warnings"`
+}
+
+// KubernetesWorkloadSnapshotContainer defines model for KubernetesWorkloadSnapshotContainer.
+type KubernetesWorkloadSnapshotContainer struct {
+	Image string `json:"image"`
+	Name  string `json:"name"`
+}
+
+// KubernetesWorkloadSnapshotEnvelope defines model for KubernetesWorkloadSnapshotEnvelope.
+type KubernetesWorkloadSnapshotEnvelope struct {
+	Data KubernetesWorkloadSnapshot `json:"data"`
+}
+
+// KubernetesWorkloadSnapshotRequest defines model for KubernetesWorkloadSnapshotRequest.
+type KubernetesWorkloadSnapshotRequest struct {
+	// ActiveDeadlineSeconds Zero leaves the Kubernetes default unchanged.
+	ActiveDeadlineSeconds int               `json:"activeDeadlineSeconds,omitempty"`
+	Annotations           map[string]string `json:"annotations,omitempty"`
+	Args                  []string          `json:"args,omitempty"`
+	BackoffLimit          int               `json:"backoffLimit,omitempty"`
+	Command               []string          `json:"command,omitempty"`
+
+	// Completions Zero leaves the Kubernetes default unchanged.
+	Completions int               `json:"completions,omitempty"`
+	Description string            `json:"description,omitempty"`
+	Labels      map[string]string `json:"labels,omitempty"`
+
+	// Namespace Namespace shared by the source workload and generated target because referenced Secrets, ConfigMaps, ServiceAccounts, and PVCs are namespace-scoped.
+	Namespace string `json:"namespace"`
+
+	// Parallelism Zero leaves the Kubernetes default unchanged.
+	Parallelism   int                                     `json:"parallelism,omitempty"`
+	RestartPolicy KubernetesWorkloadSnapshotRestartPolicy `json:"restartPolicy"`
+
+	// Schedule Required when targetKind is CronJob or WorkloadCronJob.
+	Schedule string `json:"schedule,omitempty"`
+
+	// SourceContainer Regular container to retain. When omitted, the first regular container is selected.
+	SourceContainer string                               `json:"sourceContainer,omitempty"`
+	SourceKind      KubernetesWorkloadSnapshotSourceKind `json:"sourceKind"`
+	SourceName      string                               `json:"sourceName"`
+	Suspend         bool                                 `json:"suspend,omitempty"`
+	TargetKind      KubernetesWorkloadSnapshotTargetKind `json:"targetKind"`
+	TargetName      string                               `json:"targetName"`
+}
+
+// KubernetesWorkloadSnapshotRestartPolicy defines model for KubernetesWorkloadSnapshotRestartPolicy.
+type KubernetesWorkloadSnapshotRestartPolicy string
+
+// KubernetesWorkloadSnapshotSourceKind defines model for KubernetesWorkloadSnapshotSourceKind.
+type KubernetesWorkloadSnapshotSourceKind string
+
+// KubernetesWorkloadSnapshotTargetKind defines model for KubernetesWorkloadSnapshotTargetKind.
+type KubernetesWorkloadSnapshotTargetKind string
+
 // LLMCallLog defines model for LLMCallLog.
 type LLMCallLog struct {
 	ActorID           string                `json:"actorId,omitempty"`
@@ -21427,6 +21577,9 @@ type PreflightKubernetesResourceCreateJSONRequestBody = KubernetesResourceCreate
 // DecideKubernetesResourceCreateScopeJSONRequestBody defines body for DecideKubernetesResourceCreateScope for application/json ContentType.
 type DecideKubernetesResourceCreateScopeJSONRequestBody = KubernetesResourceCreateScopeDecisionRequest
 
+// GenerateKubernetesWorkloadSnapshotJSONRequestBody defines body for GenerateKubernetesWorkloadSnapshot for application/json ContentType.
+type GenerateKubernetesWorkloadSnapshotJSONRequestBody = KubernetesWorkloadSnapshotRequest
+
 // RecordCompanionInteractionJSONRequestBody defines body for RecordCompanionInteraction for application/json ContentType.
 type RecordCompanionInteractionJSONRequestBody = CompanionInteractionRequest
 
@@ -21526,6 +21679,9 @@ type TriggerManifestSourceWebhookJSONRequestBody = ManifestSyncWebhookInput
 // CreateDeliveryPlanJSONRequestBody defines body for CreateDeliveryPlan for application/json ContentType.
 type CreateDeliveryPlanJSONRequestBody = DeliveryPlanInput
 
+// ExchangeDockerHostAgentEnrollmentJSONRequestBody defines body for ExchangeDockerHostAgentEnrollment for application/json ContentType.
+type ExchangeDockerHostAgentEnrollmentJSONRequestBody = DockerHostAgentEnrollmentRequest
+
 // StartDockerContainerJSONRequestBody defines body for StartDockerContainer for application/json ContentType.
 type StartDockerContainerJSONRequestBody = DockerContainerStartInput
 

package/gen/go/sohaapi/types_test.go

@@ -0,0 +1,17 @@
+package sohaapi
+
+import "testing"
+
+func TestKubernetesWorkloadSnapshotRequestGeneratedShape(t *testing.T) {
+	request := KubernetesWorkloadSnapshotRequest{
+		Namespace:     "default",
+		SourceKind:    KubernetesWorkloadSnapshotSourceKindDeployment,
+		SourceName:    "reports",
+		TargetKind:    KubernetesWorkloadSnapshotTargetKindCronJob,
+		TargetName:    "reports-schedule",
+		RestartPolicy: KubernetesWorkloadSnapshotRestartPolicyNever,
+	}
+	if request.Namespace != "default" {
+		t.Fatalf("namespace = %q, want default", request.Namespace)
+	}
+}

package/gen/ts/sohaapi/index.ts

@@ -2065,6 +2065,22 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/docker/agent-installations/{operationID}/enroll": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["exchangeDockerHostAgentEnrollment"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/docker/hosts/quick-create/plan": {
         parameters: {
             query?: never;
@@ -4546,6 +4562,22 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/clusters/{clusterID}/resource-creation/workload-snapshot": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["generateKubernetesWorkloadSnapshot"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/clusters/{clusterID}/resource-creation/preflight": {
         parameters: {
             query?: never;
@@ -15240,6 +15272,34 @@ export interface components {
         DockerHostAgentInstallationEnvelope: {
             data: components["schemas"]["DockerHostAgentInstallation"];
         };
+        DockerHostAgentEnrollmentRequest: {
+            agentId: string;
+            /**
+             * Format: password
+             * @description Short-lived one-time secret delivered only inside the installer.
+             */
+            enrollmentToken: string;
+        };
+        DockerHostAgentCredentials: {
+            hostId: string;
+            operationId: string;
+            agentId: string;
+            /**
+             * Format: password
+             * @description Credential for the Agent's local HTTP API, returned only by the successful enrollment response.
+             */
+            agentBearerToken: string;
+            /**
+             * Format: password
+             * @description Revocable credential restricted to Docker operations for this host.
+             */
+            runtimeBearerToken: string;
+            /** Format: date-time */
+            issuedAt: string;
+        };
+        DockerHostAgentCredentialsEnvelope: {
+            data: components["schemas"]["DockerHostAgentCredentials"];
+        };
         /** @enum {string} */
         ObservabilityProviderSignal: "logs" | "metrics" | "traces" | "profiles";
         /** @enum {string} */
@@ -15910,6 +15970,57 @@ export interface components {
             status?: components["schemas"]["LogStreamStatus"];
         } & (unknown & unknown);
         /** @enum {string} */
+        KubernetesWorkloadSnapshotSourceKind: "Deployment" | "StatefulSet" | "DaemonSet";
+        /** @enum {string} */
+        KubernetesWorkloadSnapshotTargetKind: "Job" | "CronJob" | "WorkloadCronJob";
+        /** @enum {string} */
+        KubernetesWorkloadSnapshotRestartPolicy: "Never" | "OnFailure";
+        KubernetesWorkloadSnapshotRequest: {
+            /** @description Namespace shared by the source workload and generated target because referenced Secrets, ConfigMaps, ServiceAccounts, and PVCs are namespace-scoped. */
+            namespace: string;
+            sourceKind: components["schemas"]["KubernetesWorkloadSnapshotSourceKind"];
+            sourceName: string;
+            /** @description Regular container to retain. When omitted, the first regular container is selected. */
+            sourceContainer?: string;
+            targetKind: components["schemas"]["KubernetesWorkloadSnapshotTargetKind"];
+            targetName: string;
+            description?: string;
+            labels?: {
+                [key: string]: string;
+            };
+            annotations?: {
+                [key: string]: string;
+            };
+            command?: string[];
+            args?: string[];
+            restartPolicy: components["schemas"]["KubernetesWorkloadSnapshotRestartPolicy"];
+            /** @description Zero leaves the Kubernetes default unchanged. */
+            parallelism?: number;
+            /** @description Zero leaves the Kubernetes default unchanged. */
+            completions?: number;
+            backoffLimit?: number;
+            /** @description Zero leaves the Kubernetes default unchanged. */
+            activeDeadlineSeconds?: number;
+            /** @description Required when targetKind is CronJob or WorkloadCronJob. */
+            schedule?: string;
+            suspend?: boolean;
+        };
+        KubernetesWorkloadSnapshotContainer: {
+            name: string;
+            image: string;
+        };
+        KubernetesWorkloadSnapshot: {
+            /** @description Generated native batch/v1 Job or CronJob YAML, or workloads.soha.io/v1alpha1 WorkloadCronJob YAML whose selected container image follows the source workload, ready for the existing resource-creation preflight. */
+            content: string;
+            sourceUid: string;
+            selectedContainer: string;
+            containers: components["schemas"]["KubernetesWorkloadSnapshotContainer"][];
+            warnings: string[];
+        };
+        KubernetesWorkloadSnapshotEnvelope: {
+            data: components["schemas"]["KubernetesWorkloadSnapshot"];
+        };
+        /** @enum {string} */
         KubernetesResourceCreateSource: "list" | "global_yaml" | "form";
         /** @enum {string} */
         KubernetesResourceScopeMode: "namespace" | "cluster";
@@ -19162,6 +19273,9 @@ export type AgentInstallation = components['schemas']['AgentInstallation'];
 export type AgentInstallationEnvelope = components['schemas']['AgentInstallationEnvelope'];
 export type DockerHostAgentInstallation = components['schemas']['DockerHostAgentInstallation'];
 export type DockerHostAgentInstallationEnvelope = components['schemas']['DockerHostAgentInstallationEnvelope'];
+export type DockerHostAgentEnrollmentRequest = components['schemas']['DockerHostAgentEnrollmentRequest'];
+export type DockerHostAgentCredentials = components['schemas']['DockerHostAgentCredentials'];
+export type DockerHostAgentCredentialsEnvelope = components['schemas']['DockerHostAgentCredentialsEnvelope'];
 export type ObservabilityProviderSignal = components['schemas']['ObservabilityProviderSignal'];
 export type ObservabilityProviderRuntimeMode = components['schemas']['ObservabilityProviderRuntimeMode'];
 export type ObservabilityProviderStatus = components['schemas']['ObservabilityProviderStatus'];
@@ -19262,6 +19376,13 @@ export type LogPage = components['schemas']['LogPage'];
 export type LogPageEnvelope = components['schemas']['LogPageEnvelope'];
 export type LogStreamStatus = components['schemas']['LogStreamStatus'];
 export type LogStreamEvent = components['schemas']['LogStreamEvent'];
+export type KubernetesWorkloadSnapshotSourceKind = components['schemas']['KubernetesWorkloadSnapshotSourceKind'];
+export type KubernetesWorkloadSnapshotTargetKind = components['schemas']['KubernetesWorkloadSnapshotTargetKind'];
+export type KubernetesWorkloadSnapshotRestartPolicy = components['schemas']['KubernetesWorkloadSnapshotRestartPolicy'];
+export type KubernetesWorkloadSnapshotRequest = components['schemas']['KubernetesWorkloadSnapshotRequest'];
+export type KubernetesWorkloadSnapshotContainer = components['schemas']['KubernetesWorkloadSnapshotContainer'];
+export type KubernetesWorkloadSnapshot = components['schemas']['KubernetesWorkloadSnapshot'];
+export type KubernetesWorkloadSnapshotEnvelope = components['schemas']['KubernetesWorkloadSnapshotEnvelope'];
 export type KubernetesResourceCreateSource = components['schemas']['KubernetesResourceCreateSource'];
 export type KubernetesResourceScopeMode = components['schemas']['KubernetesResourceScopeMode'];
 export type KubernetesResourceAction = components['schemas']['KubernetesResourceAction'];
@@ -23776,6 +23897,38 @@ export interface operations {
             410: components["responses"]["Error"];
         };
     };
+    exchangeDockerHostAgentEnrollment: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                operationID: components["parameters"]["OperationID"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DockerHostAgentEnrollmentRequest"];
+            };
+        };
+        responses: {
+            /** @description One-time host-bound Agent and control-plane credentials. The enrollment token is atomically consumed by a successful response. */
+            201: {
+                headers: {
+                    /** @description Prevents credential responses from being cached. */
+                    "Cache-Control"?: "no-store";
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DockerHostAgentCredentialsEnvelope"];
+                };
+            };
+            400: components["responses"]["Error"];
+            404: components["responses"]["Error"];
+            409: components["responses"]["Error"];
+            410: components["responses"]["Error"];
+        };
+    };
     planDockerHostQuickCreate: {
         parameters: {
             query?: never;
@@ -28160,6 +28313,35 @@ export interface operations {
             404: components["responses"]["Error"];
         };
     };
+    generateKubernetesWorkloadSnapshot: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                clusterID: components["parameters"]["ClusterID"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["KubernetesWorkloadSnapshotRequest"];
+            };
+        };
+        responses: {
+            /** @description A native Job or CronJob manifest, or a workloads.soha.io/v1alpha1 WorkloadCronJob manifest, generated from a same-namespace workload Pod template. This operation does not create resources. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["KubernetesWorkloadSnapshotEnvelope"];
+                };
+            };
+            400: components["responses"]["Error"];
+            403: components["responses"]["Error"];
+            404: components["responses"]["Error"];
+        };
+    };
     preflightKubernetesResourceCreate: {
         parameters: {
             query?: never;