@lostgradient/weft 0.2.0

package/dist/server/operations/stream-workflow-sse.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { FAULT_CODE_TO_HTTP_STATUS } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+import { parseOptionalSequenceCursor } from "../sequence-cursor.js";
+import { invalidParamsFault, jsonErrorResponse } from "./operation-helpers.js";
+import { createStoredChunkSSEStream, SSE_RESPONSE_HEADERS } from "./sse-stream.js";
+const TOKENS_STREAM_KEY = "tokens", streamWorkflowSseInput = z.object({
+  workflowId: z.string().min(1),
+  after: z.unknown().optional()
+});
+export const streamWorkflowSseOperation = defineOperation({
+  name: "weft.workflows.streams.sse",
+  mcpExposable: !1,
+  kind: "stream",
+  summary: "Stream workflow tokens as Server-Sent Events",
+  destructive: !1,
+  tags: ["Streams"],
+  inputSchema: streamWorkflowSseInput,
+  outputSchema: z.object({ chunks: z.array(z.unknown()) }),
+  eventSchema: z.object({ sequence: z.number(), value: z.unknown() }),
+  access: { kind: "public" },
+  producibleFaults: ["NotFound"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine;
+    if (await e.get(input.workflowId) === null)
+      throw {
+        code: "NotFound",
+        message: `Workflow "${input.workflowId}" not found`,
+        data: { resource: "workflow", identifier: input.workflowId }
+      };
+    let after;
+    if (input.after !== void 0) {
+      const rawCursor = typeof input.after === "string" ? input.after : typeof input.after === "number" ? String(input.after) : "", parsed = parseOptionalSequenceCursor(rawCursor, "Last-Event-ID header");
+      if (parsed.error !== void 0)
+        throw invalidParamsFault(parsed.error);
+      after = parsed.value;
+    }
+    return { chunks: after !== void 0 ? await e.getStreamChunks(input.workflowId, TOKENS_STREAM_KEY, { after }) : await e.getStreamChunks(input.workflowId, TOKENS_STREAM_KEY) };
+  }
+});
+const ACCEPT_HEADER_MUST_INCLUDE_SSE = "Accept header must include text/event-stream";
+function shapeStreamWorkflowSseFault(fault) {
+  if (fault.code === "NotFound")
+    return jsonErrorResponse(fault.message, 404);
+  if (fault.code === "InvalidParams") {
+    if (fault.message === ACCEPT_HEADER_MUST_INCLUDE_SSE)
+      return jsonErrorResponse(fault.message, 406);
+    return jsonErrorResponse(fault.message, 400);
+  }
+  if (fault.code === "EngineFailure")
+    return jsonErrorResponse("Internal server error", 500);
+  return jsonErrorResponse(fault.message, FAULT_CODE_TO_HTTP_STATUS[fault.code]);
+}
+function mapTokenChunkToText(chunk) {
+  if (typeof chunk.value === "string")
+    return chunk.value;
+  if (typeof chunk.value === "object" && chunk.value !== null && "token" in chunk.value) {
+    const { token } = chunk.value;
+    if (typeof token === "string" && token.length > 0)
+      return token;
+  }
+  return null;
+}
+function shapeStreamWorkflowSseSuccess(output) {
+  return new Response(createStoredChunkSSEStream(output.chunks, mapTokenChunkToText), {
+    status: 200,
+    headers: SSE_RESPONSE_HEADERS
+  });
+}
+export const streamWorkflowSseRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/sse",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.streams.sse",
+  transportKind: "sse",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    after: { kind: "header", headerName: "Last-Event-ID" }
+  },
+  extractInput: async (request, pathParams) => {
+    if (!(request.headers.get("Accept") ?? "").includes("text/event-stream"))
+      throw invalidParamsFault(ACCEPT_HEADER_MUST_INCLUDE_SSE);
+    const rawLastEventId = request.headers.get("Last-Event-ID");
+    return {
+      workflowId: pathParams.id ?? "",
+      ...rawLastEventId !== null ? { after: rawLastEventId } : {}
+    };
+  },
+  success: { kind: "streaming", mediaType: "text/event-stream" },
+  shapeSuccess: shapeStreamWorkflowSseSuccess,
+  shapeFault: shapeStreamWorkflowSseFault
+};

package/dist/server/operations/submit-review-decision.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const submitReviewDecisionInput: z.ZodObject<{
+    reviewId: z.ZodString;
+    decision: z.ZodOptional<z.ZodUnknown>;
+    reviewer: z.ZodOptional<z.ZodUnknown>;
+    feedback: z.ZodOptional<z.ZodUnknown>;
+    workflowId: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const submitReviewDecisionOutput: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type SubmitReviewDecisionInput = z.infer<typeof submitReviewDecisionInput>;
+export type SubmitReviewDecisionOutput = z.infer<typeof submitReviewDecisionOutput>;
+export declare const submitReviewDecisionOperation: import("../operation-catalog.ts").OperationDefinition<{
+    reviewId: string;
+    decision?: unknown;
+    reviewer?: unknown;
+    feedback?: unknown;
+    workflowId?: unknown;
+}, {
+    ok: true;
+}>;
+export declare const submitReviewDecisionRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/submit-review-decision.js

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const VALID_DECISIONS = [
+  "approved",
+  "rejected",
+  "needs-changes"
+], submitReviewDecisionInput = z.object({
+  reviewId: z.string().min(1),
+  decision: z.unknown().optional(),
+  reviewer: z.unknown().optional(),
+  feedback: z.unknown().optional(),
+  workflowId: z.unknown().optional()
+}), submitReviewDecisionOutput = z.object({
+  ok: z.literal(!0)
+});
+function validateReviewDecisionInput(input) {
+  if (typeof input.decision !== "string" || typeof input.reviewer !== "string")
+    throw {
+      code: "InvalidParams",
+      message: "Missing required fields: decision, reviewer",
+      data: { issues: [] }
+    };
+  if (!VALID_DECISIONS.includes(input.decision))
+    throw {
+      code: "InvalidParams",
+      message: `Invalid decision "${input.decision}". Must be one of: ${VALID_DECISIONS.join(", ")}`,
+      data: { issues: [] }
+    };
+  if (input.feedback !== void 0 && typeof input.feedback !== "string")
+    throw {
+      code: "InvalidParams",
+      message: 'Field "feedback" must be a string when provided',
+      data: { issues: [] }
+    };
+  const { decision, reviewer } = input, reviewOptions = { decision, reviewer };
+  if (typeof input.feedback === "string")
+    reviewOptions.feedback = input.feedback;
+  if (typeof input.workflowId === "string")
+    reviewOptions.workflowId = input.workflowId;
+  return { decision, reviewer, reviewOptions };
+}
+function mapReviewDecisionError(error, reviewId) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("not found"))
+    throw {
+      code: "NotFound",
+      message,
+      data: { resource: "review", identifier: reviewId }
+    };
+  throw {
+    code: "EngineFailure",
+    message,
+    data: {}
+  };
+}
+export const submitReviewDecisionOperation = defineOperation({
+  name: "weft.reviews.decision.submit",
+  mcpExposable: !1,
+  summary: "Submit a decision for a human review",
+  description: "Submit an approve/reject (or option) decision for a pending human review, resuming the waiting workflow down the corresponding branch. The decision is final and cannot be " + "retracted \u2014 the same finality as a signal. Faults with NotFound when the review is not " + "visible.",
+  destructive: !0,
+  tags: ["Reviews"],
+  inputSchema: submitReviewDecisionInput,
+  outputSchema: submitReviewDecisionOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine, { reviewOptions } = validateReviewDecisionInput(input);
+    try {
+      await e.submitReview(input.reviewId, reviewOptions);
+      return { ok: !0 };
+    } catch (error) {
+      mapReviewDecisionError(error, input.reviewId);
+    }
+  }
+});
+function shapeSubmitReviewDecisionSuccess(output) {
+  return new Response(JSON.stringify(output), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export const submitReviewDecisionRestBinding = {
+  method: "POST",
+  path: "/v1/reviews/:reviewId/decision",
+  pathParamNames: ["reviewId"],
+  operationName: "weft.reviews.decision.submit",
+  inputSources: {
+    reviewId: { kind: "path", pathParam: "reviewId" },
+    decision: { kind: "body-field", bodyField: "decision" },
+    reviewer: { kind: "body-field", bodyField: "reviewer" },
+    feedback: { kind: "body-field", bodyField: "feedback" },
+    workflowId: { kind: "body-field", bodyField: "workflowId" }
+  },
+  extractInput: async (request, pathParams) => {
+    const body = await request.json().catch(() => {
+      throw Error("Invalid JSON body");
+    }), record = typeof body === "object" && body !== null && !Array.isArray(body) ? body : {};
+    return {
+      reviewId: pathParams.reviewId ?? "",
+      decision: record.decision,
+      reviewer: record.reviewer,
+      feedback: record.feedback,
+      workflowId: record.workflowId
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeSubmitReviewDecisionSuccess(output),
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/timeout-workflow.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const timeoutWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+export type TimeoutWorkflowInput = z.infer<typeof timeoutWorkflowInput>;
+export declare const timeoutWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, null>;
+export declare const timeoutWorkflowRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/timeout-workflow.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { shapeRestFault } from "./operation-helpers.js";
+import {
+  createSingleWorkflowControlOperation,
+  extractWorkflowIdFromPath
+} from "./single-workflow-control-operation.js";
+const timeoutWorkflowInput = z.object({
+  workflowId: z.string().min(1)
+});
+export const timeoutWorkflowOperation = createSingleWorkflowControlOperation({
+  name: "weft.workflows.timeout",
+  summary: "Force-timeout a workflow",
+  description: "Force a running workflow into the timed-out terminal state by `id`, as if its execution timeout had elapsed. Irreversible. Use for operator intervention on stuck workflows. Faults with NotFound when the workflow is not visible.",
+  destructive: !0,
+  tags: ["Workflows"],
+  inputSchema: timeoutWorkflowInput,
+  outputSchema: z.null(),
+  producibleFaults: ["NotFound"],
+  invoke: async ({ input, engine }) => {
+    await engine.timeout(input.workflowId);
+    return null;
+  }
+}), timeoutWorkflowRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/:id/timeout",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.timeout",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => extractWorkflowIdFromPath(pathParams),
+  success: { kind: "empty", status: 204 },
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/update-schedule.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const updateScheduleInput: z.ZodObject<{
+    scheduleId: z.ZodString;
+    cronExpression: z.ZodOptional<z.ZodUnknown>;
+    every: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type UpdateScheduleInput = z.infer<typeof updateScheduleInput>;
+export declare const updateScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
+    scheduleId: string;
+    cronExpression?: unknown;
+    every?: unknown;
+}, null>;
+export declare const updateScheduleRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/update-schedule.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { mapScheduleErrorToFault, validateScheduleInputCadence } from "./schedule-faults.js";
+const updateScheduleInput = z.object({
+  scheduleId: z.string().min(1),
+  cronExpression: z.unknown().optional().describe("Cron expression. Supply exactly one of cronExpression or every; runtime validation requires a non-empty string."),
+  every: z.unknown().optional().describe("Interval period (duration string or milliseconds). Supply exactly one of cronExpression or every.")
+});
+export const updateScheduleOperation = defineOperation({
+  name: "weft.schedules.update",
+  mcpExposable: !1,
+  summary: "Update a recurring schedule",
+  description: "Update an existing recurring schedule by `id`, replacing its recurrence specification, target workflow input, or start options. Returns null on success. Faults with NotFound when no schedule with the given id exists and InvalidParams for a malformed recurrence specification.",
+  destructive: !1,
+  tags: ["Schedules"],
+  inputSchema: updateScheduleInput,
+  outputSchema: z.null(),
+  access: { kind: "public" },
+  producibleFaults: ["NotFound", "Conflict"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const typedEngine = engine, spec = validateScheduleInputCadence(input);
+    try {
+      await typedEngine.updateSchedule(input.scheduleId, spec);
+      return null;
+    } catch (error) {
+      throw mapScheduleErrorToFault(input.scheduleId, error);
+    }
+  }
+}), updateScheduleRestBinding = {
+  method: "PATCH",
+  path: "/v1/schedules/:id",
+  pathParamNames: ["id"],
+  operationName: "weft.schedules.update",
+  inputSources: {
+    scheduleId: { kind: "path", pathParam: "id" },
+    cronExpression: { kind: "body-field", bodyField: "cronExpression" },
+    every: { kind: "body-field", bodyField: "every" }
+  },
+  extractInput: async (request, pathParams) => {
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      throw invalidParamsFault("Invalid JSON body");
+    }
+    if (typeof body !== "object" || body === null)
+      throw invalidParamsFault("Request body must be a JSON object");
+    const record = body;
+    return {
+      scheduleId: pathParams.id ?? "",
+      cronExpression: Object.hasOwn(record, "cronExpression") ? record.cronExpression : void 0,
+      every: Object.hasOwn(record, "every") ? record.every : void 0
+    };
+  },
+  success: { kind: "empty", status: 204 },
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/update-workflow.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const updateWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    updateName: z.ZodString;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    timeout: z.ZodOptional<z.ZodUnknown>;
+    idempotencyKey: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const updateWorkflowOutput: z.ZodObject<{
+    updateId: z.ZodString;
+    result: z.ZodUnknown;
+}, z.core.$strip>;
+export type UpdateWorkflowInput = z.infer<typeof updateWorkflowInput>;
+export type UpdateWorkflowOutput = z.infer<typeof updateWorkflowOutput>;
+export declare const updateWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    updateName: string;
+    payload?: unknown;
+    timeout?: unknown;
+    idempotencyKey?: unknown;
+}, {
+    updateId: string;
+    result: unknown;
+}>;
+export declare const updateWorkflowRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/update-workflow.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import {
+  UpdateTimeoutError,
+  UpdateValidationError,
+  WorkflowTerminalError
+} from "../../core/updates.js";
+import { defineOperation } from "../operation-registry.js";
+import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
+const DEFAULT_UPDATE_TIMEOUT_MS = 30000, updateWorkflowInput = z.object({
+  workflowId: z.string().min(1),
+  updateName: z.string().min(1),
+  payload: z.unknown().optional(),
+  timeout: z.unknown().optional(),
+  idempotencyKey: z.unknown().optional()
+}), updateWorkflowOutput = z.object({
+  updateId: z.string(),
+  result: z.unknown()
+});
+export const updateWorkflowOperation = defineOperation({
+  name: "weft.workflows.update",
+  mcpExposable: !1,
+  summary: "Send a synchronous update to a workflow",
+  description: "Invoke a named update handler on a workflow and wait for its result. Requires the workflow `id` and the update `name`; `payload` is optional. Unlike signals, updates return the handler result synchronously. Faults with NotFound when the workflow is not visible and InvalidParams when the payload exceeds the size limit.",
+  destructive: !0,
+  tags: ["Updates"],
+  inputSchema: updateWorkflowInput,
+  outputSchema: updateWorkflowOutput,
+  access: { kind: "public" },
+  producibleFaults: ["Unprocessable", "Timeout"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const typedEngine = engine, options = { timeout: typeof input.timeout === "number" ? input.timeout : DEFAULT_UPDATE_TIMEOUT_MS };
+    if (typeof input.idempotencyKey === "string")
+      options.idempotencyKey = input.idempotencyKey;
+    try {
+      const result = await typedEngine.submitCoordinatedUpdate(input.workflowId, input.updateName, input.payload, options);
+      if (result.error !== void 0)
+        throw {
+          code: "Unprocessable",
+          message: result.error,
+          data: { reason: result.error }
+        };
+      return {
+        updateId: result.updateId,
+        result: result.result
+      };
+    } catch (error) {
+      if (isOperationFault(error))
+        throw error;
+      if (error instanceof UpdateValidationError)
+        throw {
+          code: "Unprocessable",
+          message: error.message,
+          data: { reason: error.message }
+        };
+      if (error instanceof WorkflowTerminalError)
+        throw {
+          code: "Unprocessable",
+          message: error.message,
+          data: { reason: error.message }
+        };
+      if (error instanceof UpdateTimeoutError)
+        throw {
+          code: "Timeout",
+          message: error.message,
+          data: {}
+        };
+      throw {
+        code: "EngineFailure",
+        message: error instanceof Error ? error.message : String(error),
+        data: {}
+      };
+    }
+  }
+}), updateWorkflowRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/:id/update/:name",
+  pathParamNames: ["id", "name"],
+  operationName: "weft.workflows.update",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    updateName: { kind: "path", pathParam: "name" },
+    payload: { kind: "body-field", bodyField: "payload" },
+    timeout: { kind: "body-field", bodyField: "timeout" },
+    idempotencyKey: { kind: "body-field", bodyField: "idempotencyKey" }
+  },
+  extractInput: async (request, pathParams) => {
+    let payload, timeout, idempotencyKey;
+    try {
+      const body = await request.json();
+      if (typeof body === "object" && body !== null) {
+        const record = body;
+        payload = record.payload;
+        timeout = record.timeout;
+        idempotencyKey = record.idempotencyKey;
+      }
+    } catch {}
+    return {
+      workflowId: pathParams.id ?? "",
+      updateName: pathParams.name ?? "",
+      ...payload !== void 0 ? { payload } : {},
+      ...timeout !== void 0 ? { timeout } : {},
+      ...idempotencyKey !== void 0 ? { idempotencyKey } : {}
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/worker-drain.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Worker and deployment drain operations.
+ *
+ * Draining is an operator action: it keeps existing in-flight assignments
+ * visible while excluding matching workers from new routing decisions. Worker
+ * drains apply to one connected worker; deployment drains apply to every
+ * current and future worker that registers the same deployment name.
+ *
+ * @module server/operations/worker-drain
+ */
+import { z } from 'zod';
+import type { WorkerDrainMutationResult, WorkerRegistry } from '../../worker/registry.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const workerDrainInput: z.ZodObject<{
+    workerId: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const workerDrainClearInput: z.ZodObject<{
+    workerId: z.ZodString;
+}, z.core.$strip>;
+declare const deploymentDrainInput: z.ZodObject<{
+    deploymentName: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const deploymentDrainClearInput: z.ZodObject<{
+    deploymentName: z.ZodString;
+}, z.core.$strip>;
+export type WorkerDrainInput = z.infer<typeof workerDrainInput>;
+export type WorkerDrainClearInput = z.infer<typeof workerDrainClearInput>;
+export type DeploymentDrainInput = z.infer<typeof deploymentDrainInput>;
+export type DeploymentDrainClearInput = z.infer<typeof deploymentDrainClearInput>;
+export type WorkerDrainOutput = WorkerDrainMutationResult;
+type WorkerDrainOperationOptions = {
+    workerRegistry?: WorkerRegistry;
+    clock?: () => number;
+};
+export declare function createDrainWorkerOperation(options?: WorkerDrainOperationOptions): import("../operation-catalog.ts").OperationDefinition<{
+    workerId: string;
+    reason?: string | undefined;
+}, WorkerDrainMutationResult>;
+export declare function createClearWorkerDrainOperation(options?: WorkerDrainOperationOptions): import("../operation-catalog.ts").OperationDefinition<{
+    workerId: string;
+}, WorkerDrainMutationResult>;
+export declare function createDrainDeploymentOperation(options?: WorkerDrainOperationOptions): import("../operation-catalog.ts").OperationDefinition<{
+    deploymentName: string;
+    reason?: string | undefined;
+}, WorkerDrainMutationResult>;
+export declare function createClearDeploymentDrainOperation(options?: WorkerDrainOperationOptions): import("../operation-catalog.ts").OperationDefinition<{
+    deploymentName: string;
+}, WorkerDrainMutationResult>;
+export declare const drainWorkerOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workerId: string;
+    reason?: string | undefined;
+}, WorkerDrainMutationResult>;
+export declare const clearWorkerDrainOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workerId: string;
+}, WorkerDrainMutationResult>;
+export declare const drainDeploymentOperation: import("../operation-catalog.ts").OperationDefinition<{
+    deploymentName: string;
+    reason?: string | undefined;
+}, WorkerDrainMutationResult>;
+export declare const clearDeploymentDrainOperation: import("../operation-catalog.ts").OperationDefinition<{
+    deploymentName: string;
+}, WorkerDrainMutationResult>;
+export declare function createDrainWorkerRestBinding(): UnknownRestBinding;
+export declare function createClearWorkerDrainRestBinding(): UnknownRestBinding;
+export declare function createDrainDeploymentRestBinding(): UnknownRestBinding;
+export declare function createClearDeploymentDrainRestBinding(): UnknownRestBinding;
+export {};