@lostgradient/weft 0.2.0

package/dist/server/operations/list-reviews.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { shapeOperationFaultAsJson } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+const reviewStatusSchema = z.enum(["pending", "completed"]), listReviewsInput = z.object({
+  status: reviewStatusSchema.optional(),
+  workflowId: z.string().min(1).optional(),
+  reviewType: z.string().min(1).optional()
+}), pendingReviewEntrySchema = z.object({
+  status: z.literal("pending"),
+  reviewId: z.string(),
+  workflowId: z.string(),
+  artifact: z.unknown().nonoptional(),
+  reviewType: z.string(),
+  reviewers: z.array(z.string()),
+  allowPartial: z.boolean(),
+  timeout: z.number().optional(),
+  webhookUrl: z.string().optional(),
+  createdAt: z.number()
+}), completedReviewEntrySchema = pendingReviewEntrySchema.extend({
+  status: z.literal("completed"),
+  decision: z.enum(["approved", "rejected", "needs-changes"]),
+  reviewer: z.string(),
+  feedback: z.string().optional(),
+  sectionDecisions: z.record(z.string(), z.enum(["approved", "rejected"])).optional(),
+  timestamp: z.number()
+}), reviewListEntrySchema = z.union([pendingReviewEntrySchema, completedReviewEntrySchema]), listReviewsOutput = z.object({
+  items: z.array(reviewListEntrySchema)
+});
+export const listReviewsOperation = defineOperation({
+  name: "weft.reviews.list",
+  mcpExposable: !1,
+  summary: "List human review requests",
+  description: "List pending human-in-the-loop review requests, optionally filtered by workflow. Read-only. Returns each review request with its prompt, options, and originating workflow so an operator or agent can decide on it via the review-decision operation.",
+  destructive: !1,
+  tags: ["Reviews"],
+  inputSchema: listReviewsInput,
+  outputSchema: listReviewsOutput,
+  access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["reviews:read"] } },
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    return { items: await engine.listReviews(input) };
+  }
+});
+function extractListReviewsInput(request) {
+  const url = new URL(request.url), filter = {}, status = url.searchParams.get("status");
+  if (status !== null)
+    filter.status = status;
+  const workflowId = url.searchParams.get("workflowId");
+  if (workflowId !== null)
+    filter.workflowId = workflowId;
+  const reviewType = url.searchParams.get("reviewType");
+  if (reviewType !== null)
+    filter.reviewType = reviewType;
+  return filter;
+}
+function shapeListReviewsSuccess(result) {
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export const listReviewsRestBinding = {
+  method: "GET",
+  path: "/v1/reviews",
+  pathParamNames: [],
+  operationName: "weft.reviews.list",
+  inputSources: {
+    status: { kind: "query", queryParam: "status" },
+    workflowId: { kind: "query", queryParam: "workflowId" },
+    reviewType: { kind: "query", queryParam: "reviewType" }
+  },
+  extractInput: async (request) => extractListReviewsInput(request),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeListReviewsSuccess(output),
+  shapeFault: shapeOperationFaultAsJson
+};

package/dist/server/operations/list-schedules.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `weft.schedules.list` operation + REST binding.
+ *
+ * Lists recurring schedules with optional filtering. REST response matches
+ * the `handleListSchedules` shape: 200 with the paginated result,
+ * 400 for bad query params, or a JSON `{ error: <message> }` for other failures.
+ *
+ * @module server/operations/list-schedules
+ */
+import { z } from 'zod';
+import type { PaginatedResult, ScheduleSummary } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const listSchedulesInput: z.ZodObject<{
+    status: z.ZodOptional<z.ZodUnknown>;
+    workflowType: z.ZodOptional<z.ZodUnknown>;
+    limit: z.ZodOptional<z.ZodUnknown>;
+    offset: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type ListSchedulesInput = z.infer<typeof listSchedulesInput>;
+export type ListSchedulesOutput = PaginatedResult<ScheduleSummary>;
+export declare const listSchedulesOperation: import("../operation-catalog.ts").OperationDefinition<{
+    status?: unknown;
+    workflowType?: unknown;
+    limit?: unknown;
+    offset?: unknown;
+}, ListSchedulesOutput>;
+export declare const listSchedulesRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/list-schedules.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const VALID_SCHEDULE_STATUSES = new Set(["active", "paused", "cancelled"]);
+function isValidScheduleStatus(value) {
+  return VALID_SCHEDULE_STATUSES.has(value);
+}
+const listSchedulesInput = z.object({
+  status: z.unknown().optional(),
+  workflowType: z.unknown().optional(),
+  limit: z.unknown().optional(),
+  offset: z.unknown().optional()
+}), listSchedulesOutput = z.unknown();
+function applyStatusFilter(filter, input) {
+  if (input.status === void 0)
+    return;
+  const statuses = Array.isArray(input.status) ? input.status : [input.status], normalized = [];
+  for (const s of statuses) {
+    if (typeof s !== "string" || !isValidScheduleStatus(s))
+      throw invalidParamsFault('Query parameter "status" must be one of active, paused, cancelled');
+    normalized.push(s);
+  }
+  if (normalized.length === 1 && normalized[0] !== void 0)
+    filter.status = normalized[0];
+  else if (normalized.length > 1)
+    filter.status = normalized;
+}
+function applyScheduleTypeFilter(filter, input) {
+  if (input.workflowType !== void 0) {
+    if (typeof input.workflowType !== "string")
+      throw invalidParamsFault('Query parameter "workflowType" must be a string');
+    filter.workflowType = input.workflowType;
+  }
+}
+function applyPaginationFilter(filter, input) {
+  if (input.limit !== void 0) {
+    const parsed = Number(input.limit);
+    if (!Number.isInteger(parsed) || parsed < 1)
+      throw invalidParamsFault('Query parameter "limit" must be a positive integer');
+    filter.limit = Math.min(parsed, 1000);
+  }
+  if (input.offset !== void 0) {
+    const parsed = Number(input.offset);
+    if (!Number.isInteger(parsed) || parsed < 0)
+      throw invalidParamsFault('Query parameter "offset" must be a non-negative integer');
+    filter.offset = parsed;
+  }
+}
+function validateListSchedulesQuery(input) {
+  const filter = {};
+  applyStatusFilter(filter, input);
+  applyScheduleTypeFilter(filter, input);
+  applyPaginationFilter(filter, input);
+  return filter;
+}
+export const listSchedulesOperation = defineOperation({
+  name: "weft.schedules.list",
+  mcpExposable: !1,
+  summary: "List recurring schedules",
+  description: "List recurring schedules with pagination. Read-only. Returns each schedule with its recurrence specification, target workflow type, and paused state.",
+  destructive: !1,
+  tags: ["Schedules"],
+  inputSchema: listSchedulesInput,
+  outputSchema: listSchedulesOutput,
+  access: { kind: "authenticated" },
+  producibleFaults: ["Conflict"],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine, filter = validateListSchedulesQuery(input);
+    return e.listSchedules(filter);
+  }
+});
+function shapeListSchedulesFault(fault) {
+  return shapeRestFault(fault);
+}
+export const listSchedulesRestBinding = {
+  method: "GET",
+  path: "/v1/schedules",
+  pathParamNames: [],
+  operationName: "weft.schedules.list",
+  inputSources: {
+    status: { kind: "query", queryParam: "status" },
+    workflowType: { kind: "query", queryParam: "workflowType" },
+    limit: { kind: "query", queryParam: "limit" },
+    offset: { kind: "query", queryParam: "offset" }
+  },
+  extractInput: async (request) => {
+    const url = new URL(request.url), statusValues = url.searchParams.getAll("status"), result = {};
+    if (statusValues.length === 1)
+      result.status = statusValues[0];
+    else if (statusValues.length > 1)
+      result.status = statusValues;
+    const workflowType = url.searchParams.get("workflowType");
+    if (workflowType !== null)
+      result.workflowType = workflowType;
+    const limit = url.searchParams.get("limit");
+    if (limit !== null)
+      result.limit = limit;
+    const offset = url.searchParams.get("offset");
+    if (offset !== null)
+      result.offset = offset;
+    return result;
+  },
+  success: { kind: "json", status: 200 },
+  shapeFault: shapeListSchedulesFault
+};

package/dist/server/operations/list-task-queues.d.ts

@@ -0,0 +1,71 @@
+/**
+ * `weft.task.queues.list` operation + REST binding.
+ *
+ * Reports per-queue health for the operator dashboard: backlog,
+ * oldest-queued age, waiting long-poll pollers, in-flight task count,
+ * connected worker count, and scheduling policy.
+ *
+ * The queue set is the union of three sources, merged inside the
+ * operation:
+ *   1. `taskQueue.getQueueSummaries()` — queues with pending tasks or
+ *      waiters (TaskQueue-owned state).
+ *   2. `registry.getWorkerSummaries(now).map(w => w.queue)` — queues with
+ *      connected workers, so an idle queue with no backlog still appears
+ *      in the response.
+ * The same `now` snapshot is shared with the worker registry to keep
+ * per-request data internally consistent.
+ *
+ * Access is `system:read`. The `TaskQueue` is server-wide infrastructure.
+ *
+ * @module server/operations/list-task-queues
+ */
+import { z } from 'zod';
+import type { WorkerRegistry, WorkerSummary } from '../../worker/registry.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+import type { SchedulingPolicy, TaskQueueSummary } from '../task-queue-types.ts';
+import type { TaskQueue } from '../task-queue.ts';
+declare const listTaskQueuesInput: z.ZodObject<{}, z.core.$strip>;
+export type TaskQueueHealth = {
+    queue: string;
+    backlog: number;
+    oldestEnqueuedAt: number | null;
+    oldestQueuedAgeMs: number | null;
+    waitingPollers: number;
+    schedulingPolicy: SchedulingPolicy;
+    inFlight: number;
+    connectedWorkers: number;
+};
+export type ListTaskQueuesInput = z.infer<typeof listTaskQueuesInput>;
+export type ListTaskQueuesOutput = {
+    items: TaskQueueHealth[];
+};
+type ListTaskQueuesOptions = {
+    workerRegistry?: WorkerRegistry;
+    taskQueue?: TaskQueue;
+    clock?: () => number;
+};
+/**
+ * Build the `weft.task.queues.list` operation, optionally bound to a live
+ * `WorkerRegistry`, `TaskQueue`, and clock.
+ *
+ * When either runtime dependency is omitted, the operation is registered
+ * with metadata only — discovery output still describes the endpoint —
+ * but `invoke` throws if called.
+ */
+export declare function createListTaskQueuesOperation(options?: ListTaskQueuesOptions): import("../operation-catalog.ts").OperationDefinition<Record<string, never>, ListTaskQueuesOutput>;
+type MergeArgs = {
+    now: number;
+    workerSummaries: WorkerSummary[];
+    queueEntries: TaskQueueSummary[];
+    schedulingPolicy: SchedulingPolicy;
+};
+/**
+ * Join queue-owned state with worker-owned state into one stable, sorted
+ * list. Exported for unit testing the merge logic in isolation.
+ */
+export declare function mergeQueueHealth(args: MergeArgs): TaskQueueHealth[];
+/** Default discovery-only operation; live servers use `createListTaskQueuesOperation(...)`. */
+export declare const listTaskQueuesOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, ListTaskQueuesOutput>;
+/** Build the REST binding for `weft.task.queues.list`. */
+export declare function createListTaskQueuesRestBinding(): UnknownRestBinding;
+export {};

package/dist/server/operations/list-task-queues.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { shapeOperationFaultAsJson } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+const listTaskQueuesInput = z.object({}), schedulingPolicySchema = z.enum(["priority", "fifo", "lifo"]), taskQueueHealthSchema = z.object({
+  queue: z.string(),
+  backlog: z.number(),
+  oldestEnqueuedAt: z.number().nullable(),
+  oldestQueuedAgeMs: z.number().nullable(),
+  waitingPollers: z.number(),
+  schedulingPolicy: schedulingPolicySchema,
+  inFlight: z.number(),
+  connectedWorkers: z.number()
+}), listTaskQueuesOutput = z.object({
+  items: z.array(taskQueueHealthSchema)
+});
+export function createListTaskQueuesOperation(options) {
+  const workerRegistry = options?.workerRegistry, taskQueue = options?.taskQueue, clock = options?.clock ?? Date.now;
+  return defineOperation({
+    name: "weft.task.queues.list",
+    mcpExposable: !1,
+    summary: "List task queues with backlog, waiting pollers, and per-queue saturation",
+    destructive: !1,
+    tags: ["System"],
+    inputSchema: listTaskQueuesInput,
+    outputSchema: listTaskQueuesOutput,
+    access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["system:read"] } },
+    discoverable: !0,
+    transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+    unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+    invoke: async () => {
+      if (workerRegistry === void 0 || taskQueue === void 0)
+        throw Error("weft.task.queues.list invoked from a discovery-only operation registry; no WorkerRegistry or TaskQueue was wired in");
+      const now = clock(), workerSummaries = workerRegistry.getWorkerSummaries(now), queueEntries = taskQueue.getQueueSummaries();
+      return {
+        items: mergeQueueHealth({
+          now,
+          workerSummaries,
+          queueEntries,
+          schedulingPolicy: taskQueue.schedulingPolicy
+        })
+      };
+    }
+  });
+}
+function tallyWorkerLoad(workerSummaries) {
+  const perWorkerQueue = new Map;
+  for (const worker of workerSummaries) {
+    const existing = perWorkerQueue.get(worker.queue);
+    if (existing === void 0)
+      perWorkerQueue.set(worker.queue, { inFlight: worker.inFlight, connectedWorkers: 1 });
+    else {
+      existing.inFlight += worker.inFlight;
+      existing.connectedWorkers += 1;
+    }
+  }
+  return perWorkerQueue;
+}
+const EMPTY_WORKER_LOAD = { inFlight: 0, connectedWorkers: 0 };
+function buildHealthEntry(args) {
+  const { queue, now, queueEntry, fallbackSchedulingPolicy } = args, load = args.workerLoad ?? EMPTY_WORKER_LOAD, oldestEnqueuedAt = queueEntry === void 0 ? null : queueEntry.oldestEnqueuedAt, oldestQueuedAgeMs = oldestEnqueuedAt === null ? null : now - oldestEnqueuedAt;
+  return {
+    queue,
+    backlog: queueEntry === void 0 ? 0 : queueEntry.backlog,
+    oldestEnqueuedAt,
+    oldestQueuedAgeMs,
+    waitingPollers: queueEntry === void 0 ? 0 : queueEntry.waitingPollers,
+    schedulingPolicy: queueEntry === void 0 ? fallbackSchedulingPolicy : queueEntry.schedulingPolicy,
+    inFlight: load.inFlight,
+    connectedWorkers: load.connectedWorkers
+  };
+}
+export function mergeQueueHealth(args) {
+  const { now, workerSummaries, queueEntries, schedulingPolicy } = args, perWorkerQueue = tallyWorkerLoad(workerSummaries), queueNames = new Set;
+  for (const entry of queueEntries)
+    queueNames.add(entry.queue);
+  for (const queue of perWorkerQueue.keys())
+    queueNames.add(queue);
+  const entriesByQueue = new Map(queueEntries.map((entry) => [entry.queue, entry])), merged = [];
+  for (const queue of queueNames)
+    merged.push(buildHealthEntry({
+      queue,
+      now,
+      queueEntry: entriesByQueue.get(queue),
+      workerLoad: perWorkerQueue.get(queue),
+      fallbackSchedulingPolicy: schedulingPolicy
+    }));
+  return merged.toSorted((a, b) => a.queue < b.queue ? -1 : a.queue > b.queue ? 1 : 0);
+}
+export const listTaskQueuesOperation = createListTaskQueuesOperation();
+export function createListTaskQueuesRestBinding() {
+  return {
+    method: "GET",
+    path: "/v1/task-queues",
+    pathParamNames: [],
+    operationName: "weft.task.queues.list",
+    inputSources: {},
+    extractInput: async () => ({}),
+    success: { kind: "json", status: 200 },
+    shapeSuccess: (output) => new Response(JSON.stringify(output), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    }),
+    shapeFault: shapeOperationFaultAsJson
+  };
+}

package/dist/server/operations/list-workers.d.ts

@@ -0,0 +1,56 @@
+/**
+ * `weft.workers.list` operation + REST binding.
+ *
+ * Reports the connected-worker fleet for an operator-facing
+ * "Workers & Queues" view: per-worker queue assignment, advertised
+ * activities, concurrency, in-flight count, available capacity,
+ * connected/heartbeat timestamps, and heartbeat age. Routing policy is
+ * reported at the response top level so it does not drift per-worker.
+ *
+ * Access is `system:read` because the registry is server-wide
+ * infrastructure.
+ *
+ * The operation is constructed via a factory that closes over a
+ * `WorkerRegistry` and an injectable `clock`. Tests use a deterministic
+ * clock to prove the operation reads "now" exactly once per request and
+ * derives every `heartbeatAgeMs` from it.
+ *
+ * Discovery-only callers (`asyncapi`, `openapi`) may build the operation
+ * with no registry; the resulting `invoke` is a sentinel that throws if
+ * reached. No live request path uses a discovery-only registry.
+ *
+ * @module server/operations/list-workers
+ */
+import { z } from 'zod';
+import type { RoutingPolicy, WorkerDeploymentSummary, WorkerRegistry, WorkerSummary } from '../../worker/registry.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const listWorkersInput: z.ZodObject<{}, z.core.$strip>;
+export type ListWorkersInput = z.infer<typeof listWorkersInput>;
+export type ListWorkersOutput = {
+    items: WorkerSummary[];
+    deployments: WorkerDeploymentSummary[];
+    routingPolicy: RoutingPolicy;
+};
+type ListWorkersOptions = {
+    workerRegistry?: WorkerRegistry;
+    clock?: () => number;
+};
+/**
+ * Build the `weft.workers.list` operation, optionally bound to a live
+ * `WorkerRegistry` and clock.
+ *
+ * When `workerRegistry` is omitted, the operation is registered with full
+ * metadata (name, schemas, access, transports) so the public catalog
+ * stays honest, but `invoke` throws if called — this path is reserved
+ * for discovery-only registries (OpenAPI/AsyncAPI generators).
+ */
+export declare function createListWorkersOperation(options?: ListWorkersOptions): import("../operation-catalog.ts").OperationDefinition<Record<string, never>, ListWorkersOutput>;
+/** Default discovery-only operation; live servers use `createListWorkersOperation(...)`. */
+export declare const listWorkersOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, ListWorkersOutput>;
+/**
+ * Build the REST binding for `weft.workers.list`. The binding is metadata
+ * only; the live `WorkerRegistry` is wired into the operation, not the
+ * binding.
+ */
+export declare function createListWorkersRestBinding(): UnknownRestBinding;
+export {};

package/dist/server/operations/list-workers.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import { shapeOperationFaultAsJson } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+const listWorkersInput = z.object({}), routingPolicySchema = z.enum([
+  "least-loaded",
+  "round-robin",
+  "fair-share"
+]), workerHealthSchema = z.enum(["active", "draining", "drained"]), remoteWorkerJsonValueSchema = z.lazy(() => z.union([
+  z.null(),
+  z.boolean(),
+  z.number(),
+  z.string(),
+  z.array(remoteWorkerJsonValueSchema),
+  z.record(z.string(), remoteWorkerJsonValueSchema)
+])), workerSummarySchema = z.object({
+  id: z.string(),
+  queue: z.string(),
+  activities: z.array(z.string()),
+  concurrency: z.number(),
+  inFlight: z.number(),
+  availableCapacity: z.number(),
+  connectedAt: z.number(),
+  lastHeartbeatAt: z.number(),
+  heartbeatAgeMs: z.number(),
+  startedAt: z.number(),
+  capabilities: z.record(z.string(), remoteWorkerJsonValueSchema),
+  health: workerHealthSchema,
+  deploymentName: z.string().optional(),
+  buildId: z.string().optional(),
+  runtimeVersion: z.string().optional(),
+  gitSha: z.string().optional()
+}), workerDeploymentSummarySchema = z.object({
+  deploymentName: z.string().nullable(),
+  buildId: z.string().nullable(),
+  runtimeVersion: z.string().nullable(),
+  gitSha: z.string().nullable(),
+  health: workerHealthSchema,
+  workers: z.number(),
+  activeWorkers: z.number(),
+  drainingWorkers: z.number(),
+  drainedWorkers: z.number(),
+  inFlight: z.number(),
+  oldestStartedAt: z.number().nullable()
+}), listWorkersOutput = z.object({
+  items: z.array(workerSummarySchema),
+  deployments: z.array(workerDeploymentSummarySchema),
+  routingPolicy: routingPolicySchema
+});
+export function createListWorkersOperation(options) {
+  const registry = options?.workerRegistry, clock = options?.clock ?? Date.now;
+  return defineOperation({
+    name: "weft.workers.list",
+    mcpExposable: !1,
+    summary: "List connected workers, their advertised activities, and saturation",
+    description: "List workers currently connected to the engine, including each worker id, its advertised activities and workflows, drain state, and saturation. Read-only. Use this to observe the worker fleet before draining or rebalancing.",
+    destructive: !1,
+    tags: ["System"],
+    inputSchema: listWorkersInput,
+    outputSchema: listWorkersOutput,
+    access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["system:read"] } },
+    discoverable: !0,
+    transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+    unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+    invoke: async () => {
+      if (registry === void 0)
+        throw Error("weft.workers.list invoked from a discovery-only operation registry; no WorkerRegistry was wired in");
+      const now = clock();
+      return {
+        items: registry.getWorkerSummaries(now),
+        deployments: registry.getDeploymentSummaries(now),
+        routingPolicy: registry.policy
+      };
+    }
+  });
+}
+export const listWorkersOperation = createListWorkersOperation();
+export function createListWorkersRestBinding() {
+  return {
+    method: "GET",
+    path: "/v1/workers",
+    pathParamNames: [],
+    operationName: "weft.workers.list",
+    inputSources: {},
+    extractInput: async () => ({}),
+    success: { kind: "json", status: 200 },
+    shapeSuccess: (output) => new Response(JSON.stringify(output), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    }),
+    shapeFault: shapeOperationFaultAsJson
+  };
+}

package/dist/server/operations/list-workflows.d.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import type { FailureCategory, PaginatedResult, SearchAttributeValue, WorkflowStatus, WorkflowSummary } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const listWorkflowsInput: z.ZodObject<{
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<WorkflowStatus, WorkflowStatus>, z.ZodArray<z.ZodCustom<WorkflowStatus, WorkflowStatus>>]>>;
+    type: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
+        gt: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
+        lt: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
+        gte: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
+        lte: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
+    }, z.core.$strip>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    idPrefix: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    updatedAt: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executionDeadline: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<FailureCategory, FailureCategory>, z.ZodArray<z.ZodCustom<FailureCategory, FailureCategory>>]>>;
+    include: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;
+export type ListWorkflowsInput = z.infer<typeof listWorkflowsInput>;
+export type ListWorkflowsOutput = PaginatedResult<WorkflowSummary>;
+export declare const listWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    status?: WorkflowStatus | WorkflowStatus[] | undefined;
+    type?: string | undefined;
+    tags?: string[] | undefined;
+    attributes?: {
+        key: string;
+        value?: SearchAttributeValue | undefined;
+        gt?: SearchAttributeValue | undefined;
+        lt?: SearchAttributeValue | undefined;
+        gte?: SearchAttributeValue | undefined;
+        lte?: SearchAttributeValue | undefined;
+    }[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    idPrefix?: string | undefined;
+    createdAt?: {
+        gte?: number | undefined;
+        gt?: number | undefined;
+        lte?: number | undefined;
+        lt?: number | undefined;
+    } | undefined;
+    updatedAt?: {
+        gte?: number | undefined;
+        gt?: number | undefined;
+        lte?: number | undefined;
+        lt?: number | undefined;
+    } | undefined;
+    executionDeadline?: {
+        gte?: number | undefined;
+        gt?: number | undefined;
+        lte?: number | undefined;
+        lt?: number | undefined;
+    } | undefined;
+    failureCategory?: FailureCategory | FailureCategory[] | undefined;
+    include?: string | string[] | undefined;
+}, ListWorkflowsOutput>;
+export declare const listWorkflowsRestBinding: UnknownRestBinding;
+export {};