@kubb/agent 4.27.2 → 4.28.0

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

@@ -1,326 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-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 { readFileFromUrl } from './utils/read-file-from-url.js';
-import { parseYaml } from './js-yaml/index.js';
-import { nextTick } from './utils/next-tick.js';
-import { YamlParseError } from './errors/yaml-parse-error.js';
-import { makeRefId } from './utils/make-ref-id.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

@@ -1,106 +0,0 @@
-import addFormats from 'ajv-formats';
-import Ajv2020 from '@redocly/ajv/dist/2020.js';
-import AjvDraft4 from '@redocly/ajv/dist/draft4.js';
-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

@@ -1,68 +0,0 @@
-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

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

@@ -1,139 +0,0 @@
-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