@oxygen-agent/cli 1.46.0 → 1.64.5

package/node_modules/@oxygen/shared/dist/cell-format.js

@@ -0,0 +1,277 @@
+/**
+ * Shared cell display formatter for CLI, MCP widgets, and the web app.
+ *
+ * One source of truth for how a stored cell value should look to a human.
+ * Storage stays untouched — this only decides what to render.
+ *
+ * Three responsibilities:
+ *  1. Format known-typed values consistently (numeric → 1,154; timestamp → ISO/short).
+ *  2. Rescue numeric-looking values that landed in a `text` column. Headcount
+ *     and similar fields routinely arrive as text from CSV imports, AI columns,
+ *     and provider adapters, so a `text` column whose values parse cleanly as
+ *     numbers still gets thousands grouping at display time.
+ *  3. Refuse to "rescue" things that aren't actually numbers (IP addresses,
+ *     version strings, phone numbers, URLs), via {@link looksLikeNumericText}.
+ */
+const DEFAULT_LOCALE = "en-US";
+const INTEGER_RE = /^-?\d{1,15}$/;
+const DECIMAL_RE = /^-?\d{1,15}(?:\.\d{1,9})?$/;
+const GROUPED_RE = /^-?\d{1,3}(?:,\d{3})+(?:\.\d+)?$/;
+// Matches strings that contain only digits and dots with at least two dots
+// (e.g. "0.0.1.154", "192.168.1.1"). Used to *detect*, not classify; the
+// numeric-rescue path then decides whether the parts can be safely joined.
+const DOTTED_NUMERIC_RE = /^[+-]?\d+(?:\.\d+){2,}$/;
+const ENRICHMENT_VALUE_KEYS = ["value", "text", "result"];
+// Column kinds whose cell shape is a wrapper object emitted by an enrichment,
+// tool, AI, action, or formula run — for these we unwrap the carried value.
+// Manual/source columns can also legitimately hold `{value: …, source: …}`
+// JSON data the user typed themselves; we leave those untouched.
+const WRAPPER_COLUMN_KINDS = new Set([
+    "enrichment",
+    "tool",
+    "tool_enrichment",
+    "ai",
+    "action",
+    "formula",
+    "relation",
+]);
+// Digit-only strings of this length or longer are far more likely to be
+// identifiers (US phone = 10, SSN/EIN/DUNS = 9, account numbers) than
+// headcount/revenue/etc. Headcount and similar fit comfortably under this.
+const IDENTIFIER_DIGIT_LENGTH = 10;
+// Column hints that strongly suggest the column holds identifiers (where
+// applying thousands grouping or stripping leading zeros would corrupt the
+// displayed value). Matched against `label`, `key`, and `semantic*` fields.
+// We use explicit non-alphanumeric boundaries rather than `\b` because `_` is
+// a JS word character, so `\bphone\b` would not match a `phone_number` key.
+const IDENTIFIER_COLUMN_RE = /(?:^|[^a-z0-9])(phone|mobile|tel(?:ephone)?|fax|zip|postal|postcode|ssn|ein|tin|vat|gst|iban|swift|duns|sku|upc|ean|isbn|imei|customer[_ -]?(?:no|number|id)|account[_ -]?(?:no|number|id))(?:$|[^a-z0-9])/i;
+/**
+ * Canonical display string for a single cell.
+ *
+ * Returns `""` for null/undefined/empty so callers can treat the absence of
+ * a value as the absence of a string. Surface-specific concerns (HTML
+ * escaping, ellipsis budgets) belong outside this function.
+ */
+// skipcq: JS-R1005 — dispatches across cell types + surfaces; branches are intrinsic
+export function formatCellForDisplay(value, column, options) {
+    if (value === null || value === undefined || value === "")
+        return "";
+    const dataType = readDataType(column);
+    const locale = options.locale ?? DEFAULT_LOCALE;
+    if (dataType === "boolean")
+        return formatBoolean(value, options.surface);
+    if (dataType === "timestamptz")
+        return formatTimestamp(value, options.surface);
+    if (dataType === "numeric")
+        return formatNumeric(value, locale, options.surface);
+    if (isEnrichmentPayload(value) && columnHasWrapperKind(column)) {
+        const wrapped = readEnrichmentValue(value);
+        if (wrapped !== undefined) {
+            return formatCellForDisplay(wrapped, column, options);
+        }
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? formatNumberValue(value, locale) : String(value);
+    }
+    if (typeof value === "string") {
+        const rescue = rescueNumericText(value);
+        if (rescue !== null
+            && shouldRescueColumn(column)
+            && !looksLikeBareIdentifierDigits(value.trim())) {
+            options.onRescued?.(rescue);
+            return formatNumberValue(rescue, locale);
+        }
+        return value;
+    }
+    if (typeof value === "object") {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+/**
+ * Best-effort parse of a string that looks numeric (with or without thousands
+ * grouping, with or without dotted IP-style separators) into a finite number.
+ * Returns `null` when the string is clearly *not* a single number — IP
+ * addresses, version strings, phone numbers, anything alphabetic.
+ */
+export function rescueNumericText(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    if (INTEGER_RE.test(trimmed)) {
+        const n = Number(trimmed);
+        return Number.isFinite(n) ? n : null;
+    }
+    if (DECIMAL_RE.test(trimmed)) {
+        const n = Number(trimmed);
+        return Number.isFinite(n) ? n : null;
+    }
+    if (GROUPED_RE.test(trimmed)) {
+        const n = Number(trimmed.replace(/,/g, ""));
+        return Number.isFinite(n) ? n : null;
+    }
+    if (DOTTED_NUMERIC_RE.test(trimmed)) {
+        return decodeDottedNumeric(trimmed);
+    }
+    return null;
+}
+/**
+ * True when a digit-only string is shaped like an identifier — phone number,
+ * ZIP code with a preserved leading zero, SSN/EIN/DUNS, account or customer
+ * number. We refuse to rescue these even in numeric-looking text columns,
+ * because thousands-grouping (4155550123 → "4,155,550,123") or leading-zero
+ * stripping ("02101" → "2101") corrupts the displayed value.
+ */
+function looksLikeBareIdentifierDigits(trimmed) {
+    if (!/^\d+$/.test(trimmed))
+        return false;
+    if (trimmed.startsWith("0"))
+        return true;
+    return trimmed.length >= IDENTIFIER_DIGIT_LENGTH;
+}
+/**
+ * Decide whether a dotted-numeric string like `0.0.1.154` is a mangled integer
+ * (return 1154) or a real address/version (return null).
+ *
+ * Signature of a mangled number: ≥2 leading parts that are literally "0".
+ * That excludes real IPv4 ("192.168.1.1"), semver ("1.2.3"), and partial IPs
+ * ("10.0.0.1"), all of which have at most one leading zero group.
+ *
+ * Real headcount/revenue/employee values almost never start with multiple
+ * leading zeros — so this guard is conservative on the "don't break real IPs"
+ * side, while still recovering the screenshot's `0.0.1.154` shape.
+ */
+function decodeDottedNumeric(raw) {
+    const sign = raw.startsWith("-") ? -1 : 1;
+    const body = raw.replace(/^[+-]/, "");
+    const parts = body.split(".");
+    if (parts.length < 3)
+        return null;
+    let leadingZeros = 0;
+    for (const part of parts) {
+        if (part === "0")
+            leadingZeros += 1;
+        else
+            break;
+    }
+    if (leadingZeros < 2)
+        return null;
+    const concatenated = parts.join("");
+    if (!/^\d+$/.test(concatenated))
+        return null;
+    const normalized = concatenated.replace(/^0+(?=\d)/, "");
+    const n = Number(normalized || "0");
+    return Number.isFinite(n) ? sign * n : null;
+}
+/**
+ * True when a string is unambiguously numeric (integer, decimal, grouped, or
+ * a mangled dotted form we can recover). Exported for callers that want to
+ * highlight rescue cases without re-running the formatter.
+ */
+export function looksLikeNumericText(value) {
+    return rescueNumericText(value) !== null;
+}
+function readDataType(column) {
+    const raw = column?.dataType ?? column?.data_type ?? null;
+    if (!raw)
+        return null;
+    if (raw === "text" || raw === "numeric" || raw === "boolean" || raw === "timestamptz") {
+        return raw;
+    }
+    return null;
+}
+/**
+ * Rescue only applies to columns that are reasonable to interpret numerically.
+ * Allowlist `text` and `numeric` explicitly — JSONB / unknown data types fall
+ * through (a stored string like `"123456789"` in a payload column shouldn't
+ * be silently regrouped). Also skip identifier-shaped columns (phone, ZIP,
+ * DUNS, etc.) where formatting would corrupt the displayed value, and skip
+ * when the column has no metadata at all.
+ */
+function shouldRescueColumn(column) {
+    if (!column)
+        return false;
+    const dataType = readDataType(column);
+    if (dataType !== "text" && dataType !== "numeric")
+        return false;
+    return !columnLooksLikeIdentifier(column);
+}
+/**
+ * Decide whether the same value-level + column-level guards used inside
+ * `formatCellForDisplay`'s text path should rescue this string. Exposed so
+ * non-formatter callers (web grid, etc.) can stay in lockstep without
+ * duplicating the heuristic.
+ */
+export function tryRescueTextCell(value, column) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (!shouldRescueColumn(column))
+        return null;
+    if (looksLikeBareIdentifierDigits(trimmed))
+        return null;
+    return rescueNumericText(trimmed);
+}
+function columnHasWrapperKind(column) {
+    const kind = column?.kind;
+    return typeof kind === "string" && WRAPPER_COLUMN_KINDS.has(kind);
+}
+function columnLooksLikeIdentifier(column) {
+    const hints = [column.label, column.key, column.semanticType, column.semantic_type];
+    for (const hint of hints) {
+        if (typeof hint === "string" && IDENTIFIER_COLUMN_RE.test(hint))
+            return true;
+    }
+    return false;
+}
+function formatNumberValue(value, locale) {
+    // `Intl.NumberFormat` defaults to `maximumFractionDigits: 3` which silently
+    // truncates real precision on financial / scientific values. Lift the cap
+    // so cells render exactly the digits the user stored.
+    return new Intl.NumberFormat(locale, { maximumFractionDigits: 20 }).format(value);
+}
+function formatNumeric(value, locale, _surface) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return formatNumberValue(value, locale);
+    }
+    if (typeof value === "string") {
+        const rescue = rescueNumericText(value);
+        if (rescue !== null)
+            return formatNumberValue(rescue, locale);
+        return value;
+    }
+    return String(value);
+}
+function formatBoolean(value, surface) {
+    const truthy = value === true || value === "true" || value === 1 || value === "1";
+    if (surface === "cli")
+        return truthy ? "true" : "false";
+    return truthy ? "Yes" : "No";
+}
+function formatTimestamp(value, surface) {
+    if (value instanceof Date) {
+        return surface === "web" ? value.toISOString().slice(0, 10) : value.toISOString();
+    }
+    if (typeof value !== "string")
+        return String(value);
+    const trimmed = value.trim();
+    const date = new Date(trimmed);
+    if (!Number.isFinite(date.getTime()))
+        return trimmed;
+    return surface === "web" ? date.toISOString().slice(0, 10) : date.toISOString();
+}
+function isEnrichmentPayload(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readEnrichmentValue(payload) {
+    for (const key of ENRICHMENT_VALUE_KEYS) {
+        if (key in payload)
+            return payload[key];
+    }
+    return undefined;
+}

package/node_modules/@oxygen/shared/dist/column-types.d.ts

@@ -51,4 +51,5 @@ export type CoercionResult = {
  * Used by column retype: every value must coerce or the retype is rejected so
  * the table is never left half-converted.
  */
-export declare function coerceValueForDataType(value: unknown, dataType: RetypeableDataType): CoercionResult;
+export declare function coerceValueForDataType(// skipcq: JS-0045
+value: unknown, dataType: RetypeableDataType): CoercionResult;

package/node_modules/@oxygen/shared/dist/column-types.js

@@ -127,11 +127,12 @@ function isExcelSerialValue(value) {
  * Used by column retype: every value must coerce or the retype is rejected so
  * the table is never left half-converted.
  */
-export function coerceValueForDataType(value, dataType) {
+export function coerceValueForDataType(// skipcq: JS-0045
+value, dataType) {
     if (value === null || value === undefined || value === "") {
         return { ok: true, value: null };
     }
-    switch (dataType) {
+    switch (dataType) { // skipcq: JS-0047
         case "text":
             return { ok: true, value: typeof value === "string" ? value : String(value) };
         case "timestamptz": {

package/node_modules/@oxygen/shared/dist/file-import.js

@@ -92,7 +92,7 @@ export function normalizeRowsForNewTable(rows) {
 export function normalizeImportColumnKey(value) {
     const normalized = value
         .normalize("NFKD")
-        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[\u0300-\u036f]/g, "") // skipcq: JS-0117
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "_")
         .replace(/^_+|_+$/g, "")

package/node_modules/@oxygen/shared/dist/index.d.ts

@@ -1,8 +1,10 @@
 export { OXYGEN_VERSION } from "./version.js";
 export * from "./billing.js";
+export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
 export * from "./log.js";
+export * from "./provider-request-outcomes.js";
 export * from "./telemetry.js";
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;

package/node_modules/@oxygen/shared/dist/index.js

@@ -1,9 +1,11 @@
 import { OXYGEN_VERSION } from "./version.js";
 export { OXYGEN_VERSION } from "./version.js";
 export * from "./billing.js";
+export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
 export * from "./log.js";
+export * from "./provider-request-outcomes.js";
 export * from "./telemetry.js";
 export class OxygenError extends Error {
     code;

package/node_modules/@oxygen/shared/dist/log.js

@@ -41,7 +41,7 @@ function hashErrorKey(input) {
     let h1 = 0x811c9dc5 >>> 0;
     let h2 = 0xcbf29ce4 >>> 0;
     for (let i = 0; i < input.length; i++) {
-        const c = input.charCodeAt(i);
+        const c = input.charCodeAt(i); // skipcq: JS-C1002
         h1 = Math.imul(h1 ^ c, 16777619) >>> 0;
         h2 = Math.imul(h2 ^ c, 1099511628211 & 0xffffffff) >>> 0;
     }

package/node_modules/@oxygen/shared/dist/provider-request-outcomes.d.ts

@@ -0,0 +1,3 @@
+export declare const PROVIDER_REQUEST_OUTCOMES: readonly ["success", "error", "blocked"];
+export type ProviderRequestOutcome = (typeof PROVIDER_REQUEST_OUTCOMES)[number];
+export declare function isProviderRequestOutcome(value: unknown): value is ProviderRequestOutcome;

package/node_modules/@oxygen/shared/dist/provider-request-outcomes.js

@@ -0,0 +1,5 @@
+export const PROVIDER_REQUEST_OUTCOMES = ["success", "error", "blocked"];
+const PROVIDER_REQUEST_OUTCOME_SET = new Set(PROVIDER_REQUEST_OUTCOMES);
+export function isProviderRequestOutcome(value) {
+    return typeof value === "string" && PROVIDER_REQUEST_OUTCOME_SET.has(value);
+}

package/node_modules/@oxygen/shared/dist/version.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_VERSION = "1.46.0";
+export declare const OXYGEN_VERSION = "1.64.5";

package/node_modules/@oxygen/shared/dist/version.js

@@ -1 +1 @@
-export const OXYGEN_VERSION = "1.46.0";
+export const OXYGEN_VERSION = "1.64.5";

package/node_modules/@oxygen/workflows/dist/index.d.ts

@@ -223,8 +223,10 @@ export declare function buildRecipeManifest(input: {
     sourceHash?: string;
     createdAt?: Date;
 }): RecipeManifest;
-export declare function lintWorkflowManifest(value: unknown, options?: WorkflowManifestValidationOptions): WorkflowLintResult;
-export declare function lintRecipeManifest(value: unknown, options?: WorkflowManifestValidationOptions): WorkflowLintResult;
+export declare function lintWorkflowManifest(// skipcq: JS-R1005
+value: unknown, options?: WorkflowManifestValidationOptions): WorkflowLintResult;
+export declare function lintRecipeManifest(// skipcq: JS-R1005
+value: unknown, options?: WorkflowManifestValidationOptions): WorkflowLintResult;
 export declare function assertRecipeManifest(value: unknown, options?: WorkflowManifestValidationOptions): asserts value is RecipeManifest;
 export declare function assertWorkflowManifest(value: unknown, options?: WorkflowManifestValidationOptions): asserts value is WorkflowManifest;
 export declare function validateJsonSchemaValue(value: unknown, schema: JsonSchema | undefined, path?: string): JsonSchemaValidationIssue[];
@@ -236,6 +238,147 @@ export declare function runPureWorkflowFunction(input: {
     timeoutMs?: number;
     maxOutputBytes?: number;
 }): Promise<unknown>;
+export declare const workflowApplySchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "OXYGEN Workflow Apply Input";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly manifest: {
+            readonly $ref: "#/$defs/manifest";
+        };
+    };
+    readonly required: readonly ["manifest"];
+    readonly $defs: {
+        readonly manifest: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+    };
+};
+export declare const workflowCallSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "OXYGEN Workflow Call Input";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly workflow_id: {
+            readonly type: "string";
+        };
+        readonly workflow_name: {
+            readonly type: "string";
+        };
+        readonly input: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+        readonly mode: {
+            readonly enum: readonly ["dry_run", "live", "smoke_test"];
+        };
+        readonly idempotency_key: {
+            readonly type: "string";
+        };
+    };
+};
+export declare const workflowEventEmitSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "OXYGEN Workflow Event Emit Input";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly source: {
+            readonly type: "string";
+        };
+        readonly event: {
+            readonly type: "string";
+        };
+        readonly payload: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+        readonly raw_payload: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+        readonly headers: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+        readonly external_event_id: {
+            readonly type: "string";
+        };
+        readonly idempotency_key: {
+            readonly type: "string";
+        };
+        readonly mode: {
+            readonly enum: readonly ["dry_run", "live", "smoke_test"];
+        };
+    };
+    readonly required: readonly ["source", "event", "payload"];
+};
+export declare const workflowTriggerSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "OXYGEN Workflow Trigger";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly type: {
+            readonly enum: readonly ["api", "webhook", "cron"];
+        };
+        readonly trigger_id: {
+            readonly type: "string";
+        };
+        readonly trigger_name: {
+            readonly type: readonly ["string", "null"];
+        };
+        readonly secret_required: {
+            readonly type: "boolean";
+        };
+        readonly idempotency_key_path: {
+            readonly type: readonly ["string", "null"];
+        };
+        readonly cron: {
+            readonly type: "string";
+        };
+        readonly timezone: {
+            readonly type: readonly ["string", "null"];
+        };
+        readonly source: {
+            readonly type: "string";
+        };
+        readonly event: {
+            readonly type: "string";
+        };
+        readonly filters: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly path: {
+                        readonly type: "string";
+                    };
+                    readonly op: {
+                        readonly enum: readonly ["eq", "neq", "exists", "not_exists"];
+                    };
+                    readonly value: {};
+                };
+                readonly required: readonly ["path", "op"];
+            };
+        };
+        readonly status: {
+            readonly enum: readonly ["active", "disabled"];
+        };
+    };
+    readonly required: readonly ["type"];
+};
+export declare const workflowManifestSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "OXYGEN Workflow Manifest";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["manifest_version", "workflow", "steps", "source_hash", "compiler_version"];
+};
 export declare function getWorkflowApplySchema(): {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly title: "OXYGEN Workflow Apply Input";
@@ -535,145 +678,4 @@ export declare function getWorkflowSchema(subject?: "apply" | "call" | "event" |
         };
     };
 };
-export declare const workflowApplySchema: {
-    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly title: "OXYGEN Workflow Apply Input";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly properties: {
-        readonly manifest: {
-            readonly $ref: "#/$defs/manifest";
-        };
-    };
-    readonly required: readonly ["manifest"];
-    readonly $defs: {
-        readonly manifest: {
-            readonly type: "object";
-            readonly additionalProperties: true;
-        };
-    };
-};
-export declare const workflowCallSchema: {
-    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly title: "OXYGEN Workflow Call Input";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly properties: {
-        readonly workflow_id: {
-            readonly type: "string";
-        };
-        readonly workflow_name: {
-            readonly type: "string";
-        };
-        readonly input: {
-            readonly type: "object";
-            readonly additionalProperties: true;
-        };
-        readonly mode: {
-            readonly enum: readonly ["dry_run", "live", "smoke_test"];
-        };
-        readonly idempotency_key: {
-            readonly type: "string";
-        };
-    };
-};
-export declare const workflowEventEmitSchema: {
-    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly title: "OXYGEN Workflow Event Emit Input";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly properties: {
-        readonly source: {
-            readonly type: "string";
-        };
-        readonly event: {
-            readonly type: "string";
-        };
-        readonly payload: {
-            readonly type: "object";
-            readonly additionalProperties: true;
-        };
-        readonly raw_payload: {
-            readonly type: "object";
-            readonly additionalProperties: true;
-        };
-        readonly headers: {
-            readonly type: "object";
-            readonly additionalProperties: true;
-        };
-        readonly external_event_id: {
-            readonly type: "string";
-        };
-        readonly idempotency_key: {
-            readonly type: "string";
-        };
-        readonly mode: {
-            readonly enum: readonly ["dry_run", "live", "smoke_test"];
-        };
-    };
-    readonly required: readonly ["source", "event", "payload"];
-};
-export declare const workflowTriggerSchema: {
-    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly title: "OXYGEN Workflow Trigger";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly properties: {
-        readonly type: {
-            readonly enum: readonly ["api", "webhook", "cron"];
-        };
-        readonly trigger_id: {
-            readonly type: "string";
-        };
-        readonly trigger_name: {
-            readonly type: readonly ["string", "null"];
-        };
-        readonly secret_required: {
-            readonly type: "boolean";
-        };
-        readonly idempotency_key_path: {
-            readonly type: readonly ["string", "null"];
-        };
-        readonly cron: {
-            readonly type: "string";
-        };
-        readonly timezone: {
-            readonly type: readonly ["string", "null"];
-        };
-        readonly source: {
-            readonly type: "string";
-        };
-        readonly event: {
-            readonly type: "string";
-        };
-        readonly filters: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "object";
-                readonly additionalProperties: false;
-                readonly properties: {
-                    readonly path: {
-                        readonly type: "string";
-                    };
-                    readonly op: {
-                        readonly enum: readonly ["eq", "neq", "exists", "not_exists"];
-                    };
-                    readonly value: {};
-                };
-                readonly required: readonly ["path", "op"];
-            };
-        };
-        readonly status: {
-            readonly enum: readonly ["active", "disabled"];
-        };
-    };
-    readonly required: readonly ["type"];
-};
-export declare const workflowManifestSchema: {
-    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly title: "OXYGEN Workflow Manifest";
-    readonly type: "object";
-    readonly additionalProperties: true;
-    readonly required: readonly ["manifest_version", "workflow", "steps", "source_hash", "compiler_version"];
-};
 export {};