@oisincoveney/pipeline 3.24.2 → 3.24.3

package/dist/planning/graph.js

@@ -6,18 +6,16 @@ import { Graph, alg } from "@dagrejs/graphlib";
 * containers (e.g. parallel children). Nodes without children are returned
 * as-is.
 */
-function flattenNodes(nodes, childrenOf) {
-	return nodes.flatMap((node) => {
-		const children = childrenOf(node);
-		return children && children.length > 0 ? [node, ...flattenNodes(children, childrenOf)] : [node];
-	});
-}
+const flattenNodes = (nodes, childrenOf) => nodes.flatMap((node) => {
+	const children = childrenOf(node);
+	return children !== void 0 && children.length > 0 ? [node, ...flattenNodes(children, childrenOf)] : [node];
+});
 /**
 * Build an index mapping each `need` id to the (flat) nodes that declare it as a
 * dependency. The input is expected to already be flattened by the caller so
 * that the resulting index spans the whole graph.
 */
-function dependentsByNeed(nodes) {
+const dependentsByNeed = (nodes) => {
 	const index = /* @__PURE__ */ new Map();
 	for (const node of nodes) for (const need of node.needs ?? []) {
 		const dependents = index.get(need) ?? [];
@@ -25,81 +23,48 @@ function dependentsByNeed(nodes) {
 		index.set(need, dependents);
 	}
 	return index;
-}
-function createDependencyGraph(nodes, options) {
+};
+const addDependencyGraphNodes = (graph, nodes, options) => {
+	for (const [index, node] of nodes.entries()) graph.setNode(node.id, options.valueOf(node, index));
+};
+const declaredDependencyIds = (node, nodeIds, options) => [...options.dependenciesOf(node) ?? []].filter((dependencyId) => nodeIds.has(dependencyId));
+const addDependencyGraphEdges = (graph, nodes, nodeIds, options) => {
+	for (const node of nodes) for (const dependencyId of declaredDependencyIds(node, nodeIds, options)) graph.setEdge(dependencyId, node.id);
+};
+const createDependencyGraph = (nodes, options) => {
 	const nodeIds = new Set(nodes.map((node) => node.id));
 	const graph = new Graph({ directed: true });
 	addDependencyGraphNodes(graph, nodes, options);
 	addDependencyGraphEdges(graph, nodes, nodeIds, options);
 	return graph;
-}
-function addDependencyGraphNodes(graph, nodes, options) {
-	for (const [index, node] of nodes.entries()) graph.setNode(node.id, options.valueOf(node, index));
-}
-function addDependencyGraphEdges(graph, nodes, nodeIds, options) {
-	for (const node of nodes) for (const dependencyId of declaredDependencyIds(node, nodeIds, options)) graph.setEdge(dependencyId, node.id);
-}
-function declaredDependencyIds(node, nodeIds, options) {
-	return [...options.dependenciesOf(node) ?? []].filter((dependencyId) => nodeIds.has(dependencyId));
-}
-function dependencyPredecessorIds(graph, nodeId) {
-	return graph.predecessors(nodeId) ?? [];
-}
-function dependencyGraphNodeIds(graph) {
-	return graph.nodes();
-}
-function dependencyGraphHasNode(graph, nodeId) {
-	return graph.hasNode(nodeId);
-}
-function dependencyGraphValue(graph, nodeId) {
+};
+const dependencyPredecessorIds = (graph, nodeId) => graph.predecessors(nodeId) ?? [];
+const dependencyGraphNodeIds = (graph) => graph.nodes();
+const dependencyGraphHasNode = (graph, nodeId) => graph.hasNode(nodeId);
+const dependencyGraphValue = (graph, nodeId) => {
 	if (!dependencyGraphHasNode(graph, nodeId)) return;
 	return graph.node(nodeId);
-}
-function successorIds(graph, nodeId) {
-	return graph.successors(nodeId) ?? [];
-}
-function graphEdgeIds(graph) {
-	return graph.edges().map((edge) => ({
-		from: edge.v,
-		to: edge.w
-	}));
-}
-function descendantGraphValues(graph, rootId) {
+};
+const successorIds = (graph, nodeId) => graph.successors(nodeId) ?? [];
+const graphEdgeIds = (graph) => graph.edges().map((edge) => ({
+	from: edge.v,
+	to: edge.w
+}));
+const descendantGraphValues = (graph, rootId) => {
 	if (!graph.hasNode(rootId)) return [];
-	return alg.preorder(graph, rootId).slice(1).map((id) => graph.node(id)).filter((node) => Boolean(node));
-}
-function dependencyCycleIds(graph) {
-	return alg.findCycles(graph);
-}
-function topologicalDependencyOrder(graph) {
-	const visited = /* @__PURE__ */ new Set();
-	const inStack = /* @__PURE__ */ new Set();
-	const results = [];
-	for (const sink of graph.sinks()) visitForTopologicalOrder(sink, graph, visited, inStack, results);
-	if (visited.size !== graph.nodeCount()) throw new Error("workflow graph contains a dependency cycle");
-	return results;
-}
-function dependencyBatches(graph, nodeIds = graph.nodes(), compareIds = compareStrings) {
-	const remaining = new Set(nodeIds);
-	const batches = [];
-	while (remaining.size > 0) {
-		const ready = [...remaining].filter((id) => dependencyPredecessorIds(graph, id).every((dependencyId) => !remaining.has(dependencyId))).sort(compareIds);
-		if (ready.length === 0) return [];
-		batches.push(ready);
-		for (const id of ready) remaining.delete(id);
-	}
-	return batches;
-}
-function terminalDependencyItems(items, keyOf, dependenciesOf) {
+	return alg.preorder(graph, rootId).slice(1).map((id) => graph.node(id)).filter((node) => node !== void 0);
+};
+const dependencyCycleIds = (graph) => alg.findCycles(graph);
+const terminalDependencyItems = (items, keyOf, dependenciesOf) => {
 	const dependedOn = new Set(items.flatMap((item) => dependenciesOf(item) ?? []));
 	return items.filter((item) => !dependedOn.has(keyOf(item)));
-}
+};
 /**
 * Breadth-first search over the dependents index to determine whether any node
 * transitively reachable downstream of `nodeId` satisfies `matches`. Cycle-safe
 * via a visited set.
 */
-function hasReachableDependent(nodeId, index, matches) {
+const hasReachableDependent = (nodeId, index, matches) => {
 	const visited = /* @__PURE__ */ new Set();
 	const queue = [...index.get(nodeId) ?? []];
 	while (queue.length > 0) {
@@ -110,18 +75,66 @@ function hasReachableDependent(nodeId, index, matches) {
 		queue.push(...index.get(node.id) ?? []);
 	}
 	return false;
-}
+};
 /**
 * Recursively find a node by id within a node tree, descending into children
 * via the caller-supplied accessor. Returns `undefined` when absent.
 */
-function findNode(nodes, nodeId, childrenOf) {
+const findNode = (nodes, nodeId, childrenOf) => {
 	for (const node of nodes) {
 		if (node.id === nodeId) return node;
 		const child = findNode(childrenOf(node) ?? [], nodeId, childrenOf);
-		if (child) return child;
+		if (child !== void 0) return child;
 	}
-}
+};
+const markVisiting = (nodeId, visitState) => {
+	visitState.state.set(nodeId, "visiting");
+	visitState.pathIndex.set(nodeId, visitState.path.length);
+	visitState.path.push(nodeId);
+};
+const markDone = (nodeId, visitState) => {
+	visitState.state.set(nodeId, "done");
+	visitState.pathIndex.delete(nodeId);
+	visitState.path.pop();
+};
+const recordCycle = (nodeId, visitState) => {
+	const startIndex = visitState.pathIndex.get(nodeId);
+	if (startIndex === void 0) return;
+	const cycle = visitState.path.slice(startIndex);
+	const key = [...cycle].toSorted().join("\0");
+	if (visitState.cycleKeys.has(key)) return;
+	visitState.cycleKeys.add(key);
+	visitState.cycles.push(cycle);
+};
+const visitForCycles = (startId, visitState) => {
+	const frames = [{
+		index: 0,
+		nodeId: startId
+	}];
+	markVisiting(startId, visitState);
+	while (frames.length > 0) {
+		const frame = frames.at(-1);
+		if (!frame) return;
+		const dependentId = (visitState.adjacency.get(frame.nodeId) ?? [])[frame.index];
+		if (!dependentId) {
+			markDone(frame.nodeId, visitState);
+			frames.pop();
+			continue;
+		}
+		frame.index += 1;
+		const dependentState = visitState.state.get(dependentId);
+		if (dependentState === "visiting") {
+			recordCycle(dependentId, visitState);
+			continue;
+		}
+		if (dependentState === "done") continue;
+		markVisiting(dependentId, visitState);
+		frames.push({
+			index: 0,
+			nodeId: dependentId
+		});
+	}
+};
 /**
 * Find all dependency cycles in a flat node list using an iterative DFS over the
 * dependents-by-need graph. Each cycle is returned once (canonicalized by its
@@ -132,7 +145,7 @@ function findNode(nodes, nodeId, childrenOf) {
 * The traversal is iterative (an explicit frame stack) rather than recursive so
 * that deep generated workflow chains cannot overflow the call stack.
 */
-function findDependencyCycles(nodes) {
+const findDependencyCycles = (nodes) => {
 	const nodeIds = new Set(nodes.map((node) => node.id));
 	const index = dependentsByNeed(nodes);
 	const adjacency = /* @__PURE__ */ new Map();
@@ -154,82 +167,13 @@ function findDependencyCycles(nodes) {
 		});
 	}
 	return cycles;
-}
-function visitForCycles(startId, visitState) {
-	const frames = [{
-		index: 0,
-		nodeId: startId
-	}];
-	markVisiting(startId, visitState);
-	while (frames.length > 0) {
-		const frame = frames.at(-1);
-		if (!frame) return;
-		const dependentId = (visitState.adjacency.get(frame.nodeId) ?? [])[frame.index];
-		if (!dependentId) {
-			markDone(frame.nodeId, visitState);
-			frames.pop();
-			continue;
-		}
-		frame.index += 1;
-		const dependentState = visitState.state.get(dependentId);
-		if (dependentState === "visiting") {
-			recordCycle(dependentId, visitState);
-			continue;
-		}
-		if (dependentState === "done") continue;
-		markVisiting(dependentId, visitState);
-		frames.push({
-			index: 0,
-			nodeId: dependentId
-		});
-	}
-}
-function markVisiting(nodeId, visitState) {
-	visitState.state.set(nodeId, "visiting");
-	visitState.pathIndex.set(nodeId, visitState.path.length);
-	visitState.path.push(nodeId);
-}
-function markDone(nodeId, visitState) {
-	visitState.state.set(nodeId, "done");
-	visitState.pathIndex.delete(nodeId);
-	visitState.path.pop();
-}
-function recordCycle(nodeId, visitState) {
-	const startIndex = visitState.pathIndex.get(nodeId);
-	if (startIndex === void 0) return;
-	const cycle = visitState.path.slice(startIndex);
-	const key = [...cycle].sort().join("\0");
-	if (visitState.cycleKeys.has(key)) return;
-	visitState.cycleKeys.add(key);
-	visitState.cycles.push(cycle);
-}
-function visitForTopologicalOrder(startId, graph, visited, inStack, results) {
-	const frames = [];
-	pushTopologicalFrame(startId, graph, visited, inStack, frames);
-	while (frames.length > 0) visitTopologicalFrame(graph, visited, inStack, results, frames);
-}
-function visitTopologicalFrame(graph, visited, inStack, results, frames) {
-	const frame = frames.at(-1);
-	if (!frame) return;
-	const predecessorId = frame.predecessors[frame.index];
-	if (!predecessorId) {
-		completeTopologicalFrame(frame, inStack, results, frames);
-		return;
-	}
-	frame.index += 1;
-	visitTopologicalPredecessor(predecessorId, graph, visited, inStack, frames);
-}
-function completeTopologicalFrame(frame, inStack, results, frames) {
+};
+const completeTopologicalFrame = (frame, inStack, results, frames) => {
 	inStack.delete(frame.nodeId);
 	results.push(frame.nodeId);
 	frames.pop();
-}
-function visitTopologicalPredecessor(predecessorId, graph, visited, inStack, frames) {
-	if (inStack.has(predecessorId)) throw new Error("workflow graph contains a dependency cycle");
-	if (visited.has(predecessorId)) return;
-	pushTopologicalFrame(predecessorId, graph, visited, inStack, frames);
-}
-function pushTopologicalFrame(nodeId, graph, visited, inStack, frames) {
+};
+const pushTopologicalFrame = (nodeId, graph, visited, inStack, frames) => {
 	visited.add(nodeId);
 	inStack.add(nodeId);
 	frames.push({
@@ -237,9 +181,47 @@ function pushTopologicalFrame(nodeId, graph, visited, inStack, frames) {
 		nodeId,
 		predecessors: dependencyPredecessorIds(graph, nodeId)
 	});
-}
-function compareStrings(left, right) {
-	return left.localeCompare(right);
-}
+};
+const visitTopologicalPredecessor = (predecessorId, graph, visited, inStack, frames) => {
+	if (inStack.has(predecessorId)) throw new Error("workflow graph contains a dependency cycle");
+	if (visited.has(predecessorId)) return;
+	pushTopologicalFrame(predecessorId, graph, visited, inStack, frames);
+};
+const visitTopologicalFrame = (graph, visited, inStack, results, frames) => {
+	const frame = frames.at(-1);
+	if (!frame) return;
+	const predecessorId = frame.predecessors[frame.index];
+	if (!predecessorId) {
+		completeTopologicalFrame(frame, inStack, results, frames);
+		return;
+	}
+	frame.index += 1;
+	visitTopologicalPredecessor(predecessorId, graph, visited, inStack, frames);
+};
+const visitForTopologicalOrder = (startId, graph, visited, inStack, results) => {
+	const frames = [];
+	pushTopologicalFrame(startId, graph, visited, inStack, frames);
+	while (frames.length > 0) visitTopologicalFrame(graph, visited, inStack, results, frames);
+};
+const topologicalDependencyOrder = (graph) => {
+	const visited = /* @__PURE__ */ new Set();
+	const inStack = /* @__PURE__ */ new Set();
+	const results = [];
+	for (const sink of graph.sinks()) visitForTopologicalOrder(sink, graph, visited, inStack, results);
+	if (visited.size !== graph.nodeCount()) throw new Error("workflow graph contains a dependency cycle");
+	return results;
+};
+const compareStrings = (left, right) => left.localeCompare(right);
+const dependencyBatches = (graph, nodeIds = graph.nodes(), compareIds = compareStrings) => {
+	const remaining = new Set(nodeIds);
+	const batches = [];
+	while (remaining.size > 0) {
+		const ready = [...remaining].filter((id) => dependencyPredecessorIds(graph, id).every((dependencyId) => !remaining.has(dependencyId))).toSorted(compareIds);
+		if (ready.length === 0) return [];
+		batches.push(ready);
+		for (const id of ready) remaining.delete(id);
+	}
+	return batches;
+};
 //#endregion
 export { createDependencyGraph, dependencyBatches, dependencyCycleIds, dependencyGraphHasNode, dependencyGraphNodeIds, dependencyGraphValue, dependencyPredecessorIds, dependentsByNeed, descendantGraphValues, findDependencyCycles, findNode, flattenNodes, graphEdgeIds, hasReachableDependent, successorIds, terminalDependencyItems, topologicalDependencyOrder };

package/dist/remote/argo/model.d.ts

@@ -1,128 +1,110 @@
-import { z } from "zod";
+import * as Schema from "effect/Schema";
 
 //#region src/remote/argo/model.d.ts
-declare const argoWorkflowTtlStrategySchema: z.ZodObject<{
-  secondsAfterCompletion: z.ZodOptional<z.ZodNumber>;
-  secondsAfterFailure: z.ZodOptional<z.ZodNumber>;
-  secondsAfterSuccess: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-declare const argoWorkflowPodGcSchema: z.ZodObject<{
-  deleteDelayDuration: z.ZodOptional<z.ZodString>;
-  labelSelector: z.ZodOptional<z.ZodObject<{
-    matchExpressions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-      key: z.ZodString;
-      operator: z.ZodEnum<{
-        DoesNotExist: "DoesNotExist";
-        Exists: "Exists";
-        In: "In";
-        NotIn: "NotIn";
-      }>;
-      values: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>>;
-    matchLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  }, z.core.$strict>>;
-  strategy: z.ZodOptional<z.ZodEnum<{
-    OnPodCompletion: "OnPodCompletion";
-    OnPodSuccess: "OnPodSuccess";
-    OnWorkflowCompletion: "OnWorkflowCompletion";
-    OnWorkflowSuccess: "OnWorkflowSuccess";
+declare const argoWorkflowTtlStrategySchema: Schema.Struct<{
+  readonly secondsAfterCompletion: Schema.optional<Schema.Number>;
+  readonly secondsAfterFailure: Schema.optional<Schema.Number>;
+  readonly secondsAfterSuccess: Schema.optional<Schema.Number>;
+}>;
+declare const argoWorkflowPodGcSchema: Schema.Struct<{
+  readonly deleteDelayDuration: Schema.optional<Schema.NonEmptyString>;
+  readonly labelSelector: Schema.optional<Schema.Struct<{
+    readonly matchExpressions: Schema.optional<Schema.mutable<Schema.$Array<Schema.Struct<{
+      readonly key: Schema.NonEmptyString;
+      readonly operator: Schema.Literals<readonly ["In", "NotIn", "Exists", "DoesNotExist"]>;
+      readonly values: Schema.optional<Schema.mutable<Schema.$Array<Schema.String>>>;
+    }>>>>;
+    readonly matchLabels: Schema.optional<Schema.$Record<Schema.NonEmptyString, Schema.String>>;
   }>>;
-}, z.core.$strict>;
-declare const buildRunnerArgoWorkflowOptionsSchema: z.ZodObject<{
-  activeDeadlineSeconds: z.ZodOptional<z.ZodNumber>;
-  annotations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
-  brokerAuth: z.ZodObject<{
-    secretKey: z.ZodDefault<z.ZodString>;
-    secretName: z.ZodString;
-    url: z.ZodDefault<z.ZodString>;
-  }, z.core.$strict>;
-  dbAuth: z.ZodOptional<z.ZodObject<{
-    secretKey: z.ZodDefault<z.ZodString>;
-    secretName: z.ZodString;
-  }, z.core.$strict>>;
-  eventAuthSecretKey: z.ZodOptional<z.ZodString>;
-  eventAuthSecretName: z.ZodOptional<z.ZodString>;
-  generateName: z.ZodOptional<z.ZodString>;
-  gitCredentialsSecretName: z.ZodOptional<z.ZodString>;
-  githubAuthSecretName: z.ZodOptional<z.ZodString>;
-  image: z.ZodDefault<z.ZodString>;
-  imagePullPolicy: z.ZodDefault<z.ZodEnum<{
-    Always: "Always";
-    IfNotPresent: "IfNotPresent";
-    Never: "Never";
+  readonly strategy: Schema.optional<Schema.Literals<readonly ["OnPodCompletion", "OnPodSuccess", "OnWorkflowCompletion", "OnWorkflowSuccess"]>>;
+}>;
+declare const buildRunnerArgoWorkflowOptionsSchema: Schema.Struct<{
+  readonly activeDeadlineSeconds: Schema.optional<Schema.Number>;
+  readonly annotations: Schema.withDecodingDefault<Schema.$Record<Schema.NonEmptyString, Schema.UndefinedOr<Schema.NonEmptyString>>, never>;
+  readonly brokerAuth: Schema.Struct<{
+    readonly secretKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+    readonly secretName: Schema.NonEmptyString;
+    readonly url: Schema.withDecodingDefault<Schema.String, never>;
+  }>;
+  readonly dbAuth: Schema.optional<Schema.Struct<{
+    readonly secretKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+    readonly secretName: Schema.NonEmptyString;
   }>>;
-  imagePullSecretName: z.ZodOptional<z.ZodString>;
-  labels: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
-  mcpGatewayAuth: z.ZodOptional<z.ZodObject<{
-    secretKey: z.ZodDefault<z.ZodString>;
-    secretName: z.ZodString;
-  }, z.core.$strict>>;
-  name: z.ZodOptional<z.ZodString>;
-  namespace: z.ZodString;
-  npmRegistryAuthSecretName: z.ZodOptional<z.ZodString>;
-  payloadConfigMapKey: z.ZodDefault<z.ZodString>;
-  payloadConfigMapName: z.ZodString;
-  resources: z.ZodOptional<z.ZodObject<{
-    limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    requests: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  }, z.core.$strict>>;
-  serviceAccountName: z.ZodDefault<z.ZodString>;
-  ttlStrategy: z.ZodOptional<z.ZodObject<{
-    secondsAfterCompletion: z.ZodOptional<z.ZodNumber>;
-    secondsAfterFailure: z.ZodOptional<z.ZodNumber>;
-    secondsAfterSuccess: z.ZodOptional<z.ZodNumber>;
-  }, z.core.$strict>>;
-  scheduleConfigMapKey: z.ZodDefault<z.ZodString>;
-  scheduleConfigMapName: z.ZodString;
-  taskDescriptorConfigMapName: z.ZodString;
-}, z.core.$strict>;
-declare const buildDynamicRunnerArgoWorkflowOptionsSchema: z.ZodObject<{
-  activeDeadlineSeconds: z.ZodOptional<z.ZodNumber>;
-  annotations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
-  brokerAuth: z.ZodObject<{
-    secretKey: z.ZodDefault<z.ZodString>;
-    secretName: z.ZodString;
-    url: z.ZodDefault<z.ZodString>;
-  }, z.core.$strict>;
-  dbAuth: z.ZodOptional<z.ZodObject<{
-    secretKey: z.ZodDefault<z.ZodString>;
-    secretName: z.ZodString;
-  }, z.core.$strict>>;
-  eventAuthSecretKey: z.ZodOptional<z.ZodString>;
-  eventAuthSecretName: z.ZodOptional<z.ZodString>;
-  generateName: z.ZodOptional<z.ZodString>;
-  gitCredentialsSecretName: z.ZodOptional<z.ZodString>;
-  githubAuthSecretName: z.ZodOptional<z.ZodString>;
-  image: z.ZodDefault<z.ZodString>;
-  imagePullPolicy: z.ZodDefault<z.ZodEnum<{
-    Always: "Always";
-    IfNotPresent: "IfNotPresent";
-    Never: "Never";
+  readonly eventAuthSecretKey: Schema.optional<Schema.NonEmptyString>;
+  readonly eventAuthSecretName: Schema.optional<Schema.NonEmptyString>;
+  readonly generateName: Schema.optional<Schema.NonEmptyString>;
+  readonly gitCredentialsSecretName: Schema.optional<Schema.NonEmptyString>;
+  readonly githubAuthSecretName: Schema.optional<Schema.NonEmptyString>;
+  readonly image: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+  readonly imagePullPolicy: Schema.withDecodingDefault<Schema.Literals<readonly ["Always", "IfNotPresent", "Never"]>, never>;
+  readonly imagePullSecretName: Schema.optional<Schema.NonEmptyString>;
+  readonly labels: Schema.withDecodingDefault<Schema.$Record<Schema.NonEmptyString, Schema.UndefinedOr<Schema.NonEmptyString>>, never>;
+  readonly mcpGatewayAuth: Schema.optional<Schema.Struct<{
+    readonly secretKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+    readonly secretName: Schema.NonEmptyString;
   }>>;
-  imagePullSecretName: z.ZodOptional<z.ZodString>;
-  labels: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
-  mcpGatewayAuth: z.ZodOptional<z.ZodObject<{
-    secretKey: z.ZodDefault<z.ZodString>;
-    secretName: z.ZodString;
-  }, z.core.$strict>>;
-  name: z.ZodOptional<z.ZodString>;
-  namespace: z.ZodString;
-  npmRegistryAuthSecretName: z.ZodOptional<z.ZodString>;
-  payloadConfigMapKey: z.ZodDefault<z.ZodString>;
-  payloadConfigMapName: z.ZodString;
-  resources: z.ZodOptional<z.ZodObject<{
-    limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    requests: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  }, z.core.$strict>>;
-  serviceAccountName: z.ZodDefault<z.ZodString>;
-  ttlStrategy: z.ZodOptional<z.ZodObject<{
-    secondsAfterCompletion: z.ZodOptional<z.ZodNumber>;
-    secondsAfterFailure: z.ZodOptional<z.ZodNumber>;
-    secondsAfterSuccess: z.ZodOptional<z.ZodNumber>;
-  }, z.core.$strict>>;
-  workflowId: z.ZodString;
-}, z.core.$strict>;
-type ArgoWorkflowPodGC = z.infer<typeof argoWorkflowPodGcSchema>;
-type ArgoWorkflowTtlStrategy = z.infer<typeof argoWorkflowTtlStrategySchema>;
+  readonly name: Schema.optional<Schema.NonEmptyString>;
+  readonly namespace: Schema.NonEmptyString;
+  readonly npmRegistryAuthSecretName: Schema.optional<Schema.NonEmptyString>;
+  readonly payloadConfigMapKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+  readonly payloadConfigMapName: Schema.NonEmptyString;
+  readonly resources: Schema.optional<Schema.Struct<{
+    readonly limits: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly requests: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+  }>>;
+  readonly serviceAccountName: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+  readonly ttlStrategy: Schema.optional<Schema.Struct<{
+    readonly secondsAfterCompletion: Schema.optional<Schema.Number>;
+    readonly secondsAfterFailure: Schema.optional<Schema.Number>;
+    readonly secondsAfterSuccess: Schema.optional<Schema.Number>;
+  }>>;
+  readonly scheduleConfigMapKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+  readonly scheduleConfigMapName: Schema.NonEmptyString;
+  readonly taskDescriptorConfigMapName: Schema.NonEmptyString;
+}>;
+declare const buildDynamicRunnerArgoWorkflowOptionsSchema: Schema.Struct<{
+  readonly activeDeadlineSeconds: Schema.optional<Schema.Number>;
+  readonly annotations: Schema.withDecodingDefault<Schema.$Record<Schema.NonEmptyString, Schema.UndefinedOr<Schema.NonEmptyString>>, never>;
+  readonly brokerAuth: Schema.Struct<{
+    readonly secretKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+    readonly secretName: Schema.NonEmptyString;
+    readonly url: Schema.withDecodingDefault<Schema.String, never>;
+  }>;
+  readonly dbAuth: Schema.optional<Schema.Struct<{
+    readonly secretKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+    readonly secretName: Schema.NonEmptyString;
+  }>>;
+  readonly eventAuthSecretKey: Schema.optional<Schema.NonEmptyString>;
+  readonly eventAuthSecretName: Schema.optional<Schema.NonEmptyString>;
+  readonly generateName: Schema.optional<Schema.NonEmptyString>;
+  readonly gitCredentialsSecretName: Schema.optional<Schema.NonEmptyString>;
+  readonly githubAuthSecretName: Schema.optional<Schema.NonEmptyString>;
+  readonly image: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+  readonly imagePullPolicy: Schema.withDecodingDefault<Schema.Literals<readonly ["Always", "IfNotPresent", "Never"]>, never>;
+  readonly imagePullSecretName: Schema.optional<Schema.NonEmptyString>;
+  readonly labels: Schema.withDecodingDefault<Schema.$Record<Schema.NonEmptyString, Schema.UndefinedOr<Schema.NonEmptyString>>, never>;
+  readonly mcpGatewayAuth: Schema.optional<Schema.Struct<{
+    readonly secretKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+    readonly secretName: Schema.NonEmptyString;
+  }>>;
+  readonly name: Schema.optional<Schema.NonEmptyString>;
+  readonly namespace: Schema.NonEmptyString;
+  readonly npmRegistryAuthSecretName: Schema.optional<Schema.NonEmptyString>;
+  readonly payloadConfigMapKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+  readonly payloadConfigMapName: Schema.NonEmptyString;
+  readonly resources: Schema.optional<Schema.Struct<{
+    readonly limits: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly requests: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+  }>>;
+  readonly serviceAccountName: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+  readonly ttlStrategy: Schema.optional<Schema.Struct<{
+    readonly secondsAfterCompletion: Schema.optional<Schema.Number>;
+    readonly secondsAfterFailure: Schema.optional<Schema.Number>;
+    readonly secondsAfterSuccess: Schema.optional<Schema.Number>;
+  }>>;
+  readonly workflowId: Schema.NonEmptyString;
+}>;
+type ArgoWorkflowPodGC = typeof argoWorkflowPodGcSchema.Type;
+type ArgoWorkflowTtlStrategy = typeof argoWorkflowTtlStrategySchema.Type;
 //#endregion
 export { ArgoWorkflowPodGC, ArgoWorkflowTtlStrategy, argoWorkflowPodGcSchema, argoWorkflowTtlStrategySchema, buildDynamicRunnerArgoWorkflowOptionsSchema, buildRunnerArgoWorkflowOptionsSchema };