@kubb/agent 4.33.1 → 4.33.3

package/.output/server/node_modules/@redocly/openapi-core/lib/resolve.js

@@ -0,0 +1,326 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { YamlParseError } from './errors/yaml-parse-error.js';
+import { parseYaml } from './js-yaml/index.js';
+import { isRef, joinPointer, escapePointerFragment, parseRef, isAbsoluteUrl, isAnchor, isExternalValue, } from './ref-utils.js';
+import { isNamedType, SpecExtension } from './types/index.js';
+import { getOwn } from './utils/get-own.js';
+import { makeRefId } from './utils/make-ref-id.js';
+import { nextTick } from './utils/next-tick.js';
+import { readFileFromUrl } from './utils/read-file-from-url.js';
+export class Source {
+    constructor(absoluteRef, body, mimeType) {
+        this.absoluteRef = absoluteRef;
+        this.body = body;
+        this.mimeType = mimeType;
+    }
+    // pass safeLoad as argument to separate it from browser bundle
+    getAst(safeLoad) {
+        if (this._ast === undefined) {
+            this._ast = safeLoad(this.body, { filename: this.absoluteRef }) ?? undefined;
+            // fix ast representation of file with newlines only
+            if (this._ast &&
+                this._ast.kind === 0 && // KIND.scalar = 0
+                this._ast.value === '' &&
+                this._ast.startPosition !== 1) {
+                this._ast.startPosition = 1;
+                this._ast.endPosition = 1;
+            }
+        }
+        return this._ast;
+    }
+    getLines() {
+        if (this._lines === undefined) {
+            this._lines = this.body.split(/\r\n|[\n\r]/g);
+        }
+        return this._lines;
+    }
+}
+export class ResolveError extends Error {
+    constructor(originalError) {
+        super(originalError.message);
+        this.originalError = originalError;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, ResolveError.prototype);
+    }
+}
+export function makeDocumentFromString(sourceString, absoluteRef) {
+    const source = new Source(absoluteRef, sourceString);
+    try {
+        return {
+            source,
+            parsed: parseYaml(sourceString, { filename: absoluteRef }),
+        };
+    }
+    catch (e) {
+        throw new YamlParseError(e, source);
+    }
+}
+export class BaseResolver {
+    constructor(config = { http: { headers: [] } }) {
+        this.config = config;
+        this.cache = new Map();
+    }
+    getFiles() {
+        return new Set(Array.from(this.cache.keys()));
+    }
+    resolveExternalRef(base, ref) {
+        if (isAbsoluteUrl(ref)) {
+            return ref;
+        }
+        if (base && isAbsoluteUrl(base)) {
+            return new URL(ref, base).href;
+        }
+        return path.resolve(base ? path.dirname(base) : process.cwd(), ref);
+    }
+    async loadExternalRef(absoluteRef) {
+        try {
+            if (isAbsoluteUrl(absoluteRef)) {
+                const { body, mimeType } = await readFileFromUrl(absoluteRef, this.config.http);
+                return new Source(absoluteRef, body, mimeType);
+            }
+            else {
+                if (fs.lstatSync(absoluteRef).isDirectory()) {
+                    throw new Error(`Expected a file but received a folder at ${absoluteRef}.`);
+                }
+                const content = await fs.promises.readFile(absoluteRef, 'utf-8');
+                // In some cases file have \r\n line delimeters like on windows, we should skip it.
+                return new Source(absoluteRef, content.replace(/\r\n/g, '\n'));
+            }
+        }
+        catch (error) {
+            error.message = error.message.replace(', lstat', '');
+            throw new ResolveError(error);
+        }
+    }
+    parseDocument(source, isRoot = false) {
+        const ext = source.absoluteRef.substr(source.absoluteRef.lastIndexOf('.'));
+        if (!['.json', '.json', '.yml', '.yaml'].includes(ext) &&
+            !source.mimeType?.match(/(json|yaml|openapi)/) &&
+            !isRoot // always parse root
+        ) {
+            return { source, parsed: source.body };
+        }
+        try {
+            return {
+                source,
+                parsed: parseYaml(source.body, { filename: source.absoluteRef }),
+            };
+        }
+        catch (e) {
+            throw new YamlParseError(e, source);
+        }
+    }
+    async resolveDocument(base, ref, isRoot = false) {
+        const absoluteRef = this.resolveExternalRef(base, ref);
+        const cachedDocument = this.cache.get(absoluteRef);
+        if (cachedDocument) {
+            return cachedDocument;
+        }
+        const doc = this.loadExternalRef(absoluteRef).then((source) => {
+            return this.parseDocument(source, isRoot);
+        });
+        this.cache.set(absoluteRef, doc);
+        return doc;
+    }
+}
+function pushRef(head, node) {
+    return {
+        prev: head,
+        node,
+    };
+}
+function hasRef(head, node) {
+    while (head) {
+        if (head.node === node) {
+            return true;
+        }
+        head = head.prev;
+    }
+    return false;
+}
+const unknownType = { name: 'unknown', properties: {} };
+const resolvableScalarType = { name: 'scalar', properties: {} };
+export async function resolveDocument(opts) {
+    const { rootDocument, externalRefResolver, rootType } = opts;
+    const resolvedRefMap = new Map();
+    const seenNodes = new Set(); // format "${type}::${absoluteRef}${pointer}"
+    const resolvePromises = [];
+    resolveRefsInParallel(rootDocument.parsed, rootDocument, '#/', rootType);
+    let resolved;
+    do {
+        resolved = await Promise.all(resolvePromises);
+    } while (resolvePromises.length !== resolved.length);
+    return resolvedRefMap;
+    function resolveRefsInParallel(rootNode, rootNodeDocument, rootNodePointer, type) {
+        const rootNodeDocAbsoluteRef = rootNodeDocument.source.absoluteRef;
+        const anchorRefsMap = new Map();
+        walk(rootNode, type, rootNodeDocAbsoluteRef + rootNodePointer);
+        function walk(node, type, nodeAbsoluteRef) {
+            if (typeof node !== 'object' || node === null) {
+                return;
+            }
+            const nodeId = `${type.name}::${nodeAbsoluteRef}`;
+            if (seenNodes.has(nodeId)) {
+                return;
+            }
+            seenNodes.add(nodeId);
+            const [_, anchor] = Object.entries(node).find(([key]) => key === '$anchor') || [];
+            if (anchor) {
+                anchorRefsMap.set(`#${anchor}`, node);
+            }
+            if (Array.isArray(node)) {
+                const itemsType = type.items;
+                // we continue resolving unknown types, but stop early on known scalars
+                if (itemsType === undefined && type !== unknownType && type !== SpecExtension) {
+                    return;
+                }
+                const isTypeAFunction = typeof itemsType === 'function';
+                for (let i = 0; i < node.length; i++) {
+                    let itemType = isTypeAFunction
+                        ? itemsType(node[i], joinPointer(nodeAbsoluteRef, i))
+                        : itemsType;
+                    // we continue resolving unknown types, but stop early on known scalars
+                    if (itemType === undefined && type !== unknownType && type !== SpecExtension) {
+                        continue;
+                    }
+                    const value = itemType?.directResolveAs ? { $ref: node[i] } : node[i];
+                    itemType = itemType?.directResolveAs || itemType;
+                    walk(value, isNamedType(itemType) ? itemType : unknownType, joinPointer(nodeAbsoluteRef, i));
+                }
+                return;
+            }
+            for (const propName of Object.keys(node)) {
+                let propValue = node[propName];
+                let propType = getOwn(type.properties, propName);
+                if (propType === undefined)
+                    propType = type.additionalProperties;
+                if (typeof propType === 'function')
+                    propType = propType(propValue, propName);
+                if (propType === undefined)
+                    propType = unknownType;
+                if (type.extensionsPrefix &&
+                    propName.startsWith(type.extensionsPrefix) &&
+                    propType === unknownType) {
+                    propType = SpecExtension;
+                }
+                if (!isNamedType(propType) && propType?.directResolveAs) {
+                    propType = propType.directResolveAs;
+                    propValue = { $ref: propValue };
+                }
+                if (propType && propType.name === undefined && propType.resolvable !== false) {
+                    propType = resolvableScalarType;
+                }
+                if (!isNamedType(propType) || typeof propValue !== 'object') {
+                    continue;
+                }
+                walk(propValue, propType, joinPointer(nodeAbsoluteRef, escapePointerFragment(propName)));
+            }
+            if (isRef(node)) {
+                const promise = followRef(rootNodeDocument, node, {
+                    prev: null,
+                    node,
+                }).then((resolvedRef) => {
+                    if (resolvedRef.resolved) {
+                        resolveRefsInParallel(resolvedRef.node, resolvedRef.document, resolvedRef.nodePointer, type);
+                    }
+                });
+                resolvePromises.push(promise);
+            }
+            // handle example.externalValue as reference
+            if (isExternalValue(node)) {
+                const promise = followRef(rootNodeDocument, { $ref: node.externalValue }, {
+                    prev: null,
+                    node,
+                }).then((resolvedRef) => {
+                    if (resolvedRef.resolved) {
+                        resolveRefsInParallel(resolvedRef.node, resolvedRef.document, resolvedRef.nodePointer, type);
+                    }
+                });
+                resolvePromises.push(promise);
+            }
+        }
+        async function followRef(document, ref, refStack) {
+            if (hasRef(refStack.prev, ref)) {
+                throw new Error('Self-referencing circular pointer');
+            }
+            if (isAnchor(ref.$ref)) {
+                // Wait for all anchors in the document to be collected firstly.
+                await nextTick();
+                const resolvedRef = {
+                    resolved: true,
+                    isRemote: false,
+                    node: anchorRefsMap.get(ref.$ref),
+                    document,
+                    nodePointer: ref.$ref,
+                };
+                const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+                resolvedRefMap.set(refId, resolvedRef);
+                return resolvedRef;
+            }
+            const { uri, pointer } = parseRef(ref.$ref);
+            const isRemote = uri !== null &&
+                externalRefResolver.resolveExternalRef(document.source.absoluteRef, uri) !==
+                    document.source.absoluteRef;
+            let targetDoc;
+            try {
+                targetDoc = isRemote
+                    ? (await externalRefResolver.resolveDocument(document.source.absoluteRef, uri))
+                    : document;
+            }
+            catch (error) {
+                const resolvedRef = {
+                    resolved: false,
+                    isRemote,
+                    document: undefined,
+                    error: error,
+                };
+                const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+                resolvedRefMap.set(refId, resolvedRef);
+                return resolvedRef;
+            }
+            let resolvedRef = {
+                resolved: true,
+                document: targetDoc,
+                isRemote,
+                node: document.parsed,
+                nodePointer: '#/',
+            };
+            let target = targetDoc.parsed;
+            const segments = pointer;
+            for (const segment of segments) {
+                if (typeof target !== 'object') {
+                    target = undefined;
+                    break;
+                }
+                else if (target[segment] !== undefined) {
+                    target = target[segment];
+                    resolvedRef.nodePointer = joinPointer(resolvedRef.nodePointer, escapePointerFragment(segment));
+                }
+                else if (isRef(target)) {
+                    resolvedRef = await followRef(targetDoc, target, pushRef(refStack, target));
+                    targetDoc = resolvedRef.document || targetDoc;
+                    if (typeof resolvedRef.node !== 'object') {
+                        target = undefined;
+                        break;
+                    }
+                    target = resolvedRef.node[segment];
+                    resolvedRef.nodePointer = joinPointer(resolvedRef.nodePointer, escapePointerFragment(segment));
+                }
+                else {
+                    target = undefined;
+                    break;
+                }
+            }
+            resolvedRef.node = target;
+            resolvedRef.document = targetDoc;
+            const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+            if (resolvedRef.document && isRef(target)) {
+                resolvedRef = await followRef(resolvedRef.document, target, pushRef(refStack, target));
+            }
+            resolvedRefMap.set(refId, resolvedRef);
+            return { ...resolvedRef };
+        }
+    }
+}
+//# sourceMappingURL=resolve.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/ajv.js

@@ -0,0 +1,106 @@
+import Ajv2020 from '@redocly/ajv/dist/2020.js';
+import AjvDraft4 from '@redocly/ajv/dist/draft4.js';
+import addFormats from 'ajv-formats';
+import { escapePointerFragment } from '../ref-utils.js';
+const ajvInstances = {};
+export function releaseAjvInstance() {
+    ajvInstances['2020'] = undefined;
+    ajvInstances['draft4'] = undefined;
+}
+function getSchemaIdKey(dialect) {
+    return dialect === 'draft4' ? 'id' : '$id';
+}
+function getDialectBySpecVersion(specVersion) {
+    if (specVersion === 'oas2' || specVersion === 'oas3_0')
+        return 'draft4';
+    return '2020';
+}
+function getAjv(resolve, dialect) {
+    if (!ajvInstances[dialect]) {
+        const schemaIdKey = getSchemaIdKey(dialect);
+        const options = {
+            schemaId: schemaIdKey,
+            meta: true,
+            allErrors: true,
+            strictSchema: false,
+            inlineRefs: false,
+            validateSchema: false,
+            discriminator: true,
+            allowUnionTypes: true,
+            validateFormats: true,
+            passContext: true,
+            loadSchemaSync(base, $ref, $id) {
+                const decodedBase = decodeURI(base.split('#')[0]);
+                const resolvedRef = resolve({ $ref }, decodedBase);
+                if (!resolvedRef || !resolvedRef.location)
+                    return false;
+                return {
+                    [schemaIdKey]: encodeURI(resolvedRef.location.source.absoluteRef) + '#' + $id,
+                    ...resolvedRef.node,
+                };
+            },
+            logger: false,
+        };
+        ajvInstances[dialect] = dialect === '2020' ? new Ajv2020(options) : new AjvDraft4(options);
+        addFormats(ajvInstances[dialect]);
+    }
+    return ajvInstances[dialect];
+}
+function getAjvValidator(schema, loc, resolve, allowAdditionalProperties, dialect) {
+    const ajv = getAjv(resolve, dialect);
+    const $id = encodeURI(loc.absolutePointer);
+    const schemaIdKey = getSchemaIdKey(dialect);
+    if (!ajv.getSchema($id)) {
+        ajv.setDefaultUnevaluatedProperties(allowAdditionalProperties);
+        ajv.addSchema({
+            [schemaIdKey]: $id,
+            ...schema,
+        }, $id);
+    }
+    return ajv.getSchema($id);
+}
+export function validateJsonSchema(data, schema, options) {
+    const { schemaLoc, instancePath, resolve, allowAdditionalProperties, ajvContext, specVersion } = options;
+    const dialect = getDialectBySpecVersion(specVersion);
+    const validate = getAjvValidator(schema, schemaLoc, resolve, allowAdditionalProperties, dialect);
+    if (!validate)
+        return { valid: true, errors: [] }; // unresolved refs are reported
+    const dataCxt = {
+        instancePath,
+        parentData: { fake: {} },
+        parentDataProperty: 'fake',
+        rootData: {},
+        dynamicAnchors: {},
+    };
+    const valid = validate.call(ajvContext ?? {}, data, dataCxt);
+    return {
+        valid: !!valid,
+        errors: (validate.errors || []).map(beatifyErrorMessage),
+    };
+    function beatifyErrorMessage(error) {
+        let message = error.message;
+        const suggest = error.keyword === 'enum' ? error.params.allowedValues : undefined;
+        if (suggest) {
+            message += ` ${suggest.map((e) => `"${e}"`).join(', ')}`;
+        }
+        if (error.keyword === 'type') {
+            message = `type ${message}`;
+        }
+        const relativePath = error.instancePath.substring(instancePath.length + 1);
+        const propName = relativePath.substring(relativePath.lastIndexOf('/') + 1);
+        if (propName) {
+            message = `\`${propName}\` property ${message}`;
+        }
+        if (error.keyword === 'additionalProperties' || error.keyword === 'unevaluatedProperties') {
+            const property = error.params.additionalProperty || error.params.unevaluatedProperty;
+            message = `${message} \`${property}\``;
+            error.instancePath += '/' + escapePointerFragment(property);
+        }
+        return {
+            ...error,
+            message,
+            suggest,
+        };
+    }
+}
+//# sourceMappingURL=ajv.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/criteria-unique.js

@@ -0,0 +1,68 @@
+export const CriteriaUnique = () => {
+    return {
+        FailureActionObject: {
+            enter(action, { report, location }) {
+                const criterias = action?.criteria;
+                if (!Array.isArray(criterias)) {
+                    return;
+                }
+                const seen = new Set();
+                for (const criteria of criterias) {
+                    const key = JSON.stringify(criteria);
+                    if (seen.has(key)) {
+                        report({
+                            message: 'The FailureAction criteria items must be unique.',
+                            location: location.child(['criteria', criterias.indexOf(criteria)]),
+                        });
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+            },
+        },
+        SuccessActionObject: {
+            enter(action, { report, location }) {
+                const criterias = action?.criteria;
+                if (!Array.isArray(criterias)) {
+                    return;
+                }
+                const seen = new Set();
+                for (const criteria of criterias) {
+                    const key = JSON.stringify(criteria);
+                    if (seen.has(key)) {
+                        report({
+                            message: 'The SuccessAction criteria items must be unique.',
+                            location: location.child(['criteria', criterias.indexOf(criteria)]),
+                        });
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+            },
+        },
+        Step: {
+            enter(step, { report, location }) {
+                const successCriterias = step?.successCriteria;
+                if (!Array.isArray(successCriterias)) {
+                    return;
+                }
+                const seen = new Set();
+                for (const criteria of successCriterias) {
+                    const key = JSON.stringify(criteria);
+                    if (seen.has(key)) {
+                        report({
+                            message: 'The Step SuccessCriteria items must be unique.',
+                            location: location.child(['successCriteria', successCriterias.indexOf(criteria)]),
+                        });
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=criteria-unique.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/index.js

@@ -0,0 +1,52 @@
+import { SourceDescriptionType } from '../arazzo/sourceDescription-type.js';
+import { Assertions } from '../common/assertions/index.js';
+import { NoEnumTypeMismatch } from '../common/no-enum-type-mismatch.js';
+import { NoRequiredSchemaPropertiesUndefined } from '../common/no-required-schema-properties-undefined.js';
+import { NoSchemaTypeMismatch } from '../common/no-schema-type-mismatch.js';
+import { NoUnresolvedRefs } from '../common/no-unresolved-refs.js';
+import { Struct } from '../common/struct.js';
+import { NoCriteriaXpath } from '../respect/no-criteria-xpath.js';
+import { NoXSecurityBothSchemeAndSchemeName } from '../respect/no-x-security-both-scheme-and-scheme-name.js';
+import { NoXSecuritySchemeNameWithoutOpenAPI } from '../respect/no-x-security-scheme-name-without-openapi.js';
+import { RespectSupportedVersions } from '../respect/respect-supported-versions.js';
+import { XSecuritySchemeNameReference } from '../respect/x-security-scheme-name-reference.js';
+import { XSecuritySchemaRequiredValues } from '../respect/x-security-scheme-required-values.js';
+import { CriteriaUnique } from './criteria-unique.js';
+import { OutputsDefined } from './outputs-defined.js';
+import { ParametersUnique } from './parameters-unique.js';
+import { RequestBodyReplacementsUnique } from './requestBody-replacements-unique.js';
+import { SourceDescriptionsNameUnique } from './sourceDescriptions-name-unique.js';
+import { SourceDescriptionsNotEmpty } from './sourceDescriptions-not-empty.js';
+import { StepOnFailureUnique } from './step-onFailure-unique.js';
+import { StepOnSuccessUnique } from './step-onSuccess-unique.js';
+import { StepIdUnique } from './stepId-unique.js';
+import { WorkflowDependsOn } from './workflow-dependsOn.js';
+import { WorkflowIdUnique } from './workflowId-unique.js';
+export const rules = {
+    assertions: Assertions,
+    'criteria-unique': CriteriaUnique,
+    'no-criteria-xpath': NoCriteriaXpath,
+    'no-enum-type-mismatch': NoEnumTypeMismatch,
+    'no-required-schema-properties-undefined': NoRequiredSchemaPropertiesUndefined,
+    'no-schema-type-mismatch': NoSchemaTypeMismatch,
+    'no-unresolved-refs': NoUnresolvedRefs,
+    'no-x-security-both-scheme-and-scheme-name': NoXSecurityBothSchemeAndSchemeName,
+    'no-x-security-scheme-name-without-openapi': NoXSecuritySchemeNameWithoutOpenAPI,
+    'outputs-defined': OutputsDefined,
+    'parameters-unique': ParametersUnique,
+    'requestBody-replacements-unique': RequestBodyReplacementsUnique,
+    'respect-supported-versions': RespectSupportedVersions,
+    'sourceDescription-name-unique': SourceDescriptionsNameUnique,
+    'sourceDescription-type': SourceDescriptionType,
+    'sourceDescriptions-not-empty': SourceDescriptionsNotEmpty,
+    'step-onFailure-unique': StepOnFailureUnique,
+    'step-onSuccess-unique': StepOnSuccessUnique,
+    'stepId-unique': StepIdUnique,
+    struct: Struct,
+    'workflow-dependsOn': WorkflowDependsOn,
+    'workflowId-unique': WorkflowIdUnique,
+    'x-security-scheme-name-reference': XSecuritySchemeNameReference,
+    'x-security-scheme-required-values': XSecuritySchemaRequiredValues,
+};
+export const preprocessors = {};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/outputs-defined.js

@@ -0,0 +1,139 @@
+import { isPlainObject } from '../../utils/is-plain-object.js';
+export const OutputsDefined = () => {
+    const definedWorkflowOutputs = new Map();
+    const definedStepOutputs = new Map();
+    // Store validation tasks to run after all outputs are collected
+    const deferredValidationTasks = [];
+    // Match $workflows.{id}.outputs.{key} pattern
+    function matchWorkflowOutput({ value, report, location, path, definedWorkflowOutputs, }) {
+        const workflowOutputPattern = /\$workflows\.([^.\s]+)\.outputs\.([^.\s}\]#]+)/g;
+        let match;
+        while ((match = workflowOutputPattern.exec(value)) !== null) {
+            const [fullMatch, workflowId, outputKey] = match;
+            const definedKeys = definedWorkflowOutputs.get(workflowId);
+            if (!definedKeys) {
+                report({
+                    message: `Workflow "${workflowId}" referenced in runtime expression "${fullMatch}" is not defined or has no outputs.`,
+                    location: location.child(path),
+                });
+            }
+            else if (!definedKeys.includes(outputKey)) {
+                report({
+                    message: `Output key "${outputKey}" is not defined in workflow "${workflowId}". Available outputs: [ ${definedKeys.join(', ')} ].`,
+                    location: location.child(path),
+                });
+            }
+        }
+    }
+    // Match $steps.{id}.outputs.{key} pattern
+    function matchStepOutput({ value, report, location, path, definedStepOutputs, }) {
+        const stepOutputPattern = /\$steps\.([^.\s]+)\.outputs\.([^.\s}\]#]+)/g;
+        let match;
+        while ((match = stepOutputPattern.exec(value)) !== null) {
+            const [fullMatch, stepId, outputKey] = match;
+            const definedKeys = definedStepOutputs.get(stepId);
+            if (!definedKeys) {
+                report({
+                    message: `Step "${stepId}" referenced in runtime expression "${fullMatch}" is not defined or has no outputs.`,
+                    location: location.child(path),
+                });
+            }
+            else if (!definedKeys.includes(outputKey)) {
+                report({
+                    message: `Output key "${outputKey}" is not defined in step "${stepId}". Available outputs: [ ${definedKeys.join(', ')} ].`,
+                    location: location.child(path),
+                });
+            }
+        }
+    }
+    function checkRuntimeExpressions(value, ctx, path = []) {
+        if (typeof value === 'string') {
+            matchWorkflowOutput({
+                value,
+                report: ctx.report,
+                location: ctx.location,
+                path,
+                definedWorkflowOutputs,
+            });
+            matchStepOutput({
+                value,
+                report: ctx.report,
+                location: ctx.location,
+                path,
+                definedStepOutputs,
+            });
+        }
+        else if (isPlainObject(value) || Array.isArray(value)) {
+            for (const [key, val] of Object.entries(value)) {
+                checkRuntimeExpressions(val, ctx, [...path, key]);
+            }
+        }
+    }
+    return {
+        Step: {
+            enter(step, { report: _report, location: _location }) {
+                if (!step.outputs)
+                    return;
+                definedStepOutputs.set(step.stepId, Object.keys(step.outputs));
+            },
+        },
+        Workflow: {
+            enter(workflow, { report: _report, location: _location }) {
+                if (!workflow.outputs)
+                    return;
+                definedWorkflowOutputs.set(workflow.workflowId, Object.keys(workflow.outputs));
+            },
+        },
+        Parameters: {
+            enter(parameters, ctx) {
+                deferredValidationTasks.push(() => {
+                    checkRuntimeExpressions(parameters, ctx);
+                });
+            },
+        },
+        RequestBody: {
+            enter(requestBody, ctx) {
+                deferredValidationTasks.push(() => {
+                    checkRuntimeExpressions(requestBody, ctx);
+                });
+            },
+        },
+        CriterionObject: {
+            enter(criteria, ctx) {
+                deferredValidationTasks.push(() => {
+                    checkRuntimeExpressions(criteria.condition, ctx);
+                });
+            },
+        },
+        Outputs: {
+            enter(outputs, ctx) {
+                deferredValidationTasks.push(() => {
+                    checkRuntimeExpressions(outputs, ctx);
+                });
+            },
+        },
+        ExtendedSecurity: {
+            enter(extendedSecurity, ctx) {
+                deferredValidationTasks.push(() => {
+                    checkRuntimeExpressions(extendedSecurity, ctx);
+                });
+            },
+        },
+        ExtendedOperation: {
+            enter(extendedOperation, ctx) {
+                deferredValidationTasks.push(() => {
+                    checkRuntimeExpressions(extendedOperation, ctx);
+                });
+            },
+        },
+        Root: {
+            leave() {
+                // Run all deferred validations after all outputs are collected
+                for (const task of deferredValidationTasks) {
+                    task();
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=outputs-defined.js.map