@kubb/agent 4.33.1 → 4.33.2

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

@@ -0,0 +1,289 @@
+const spec = {
+    rules: {
+        struct: 'error',
+        'no-unresolved-refs': 'error',
+    },
+    oas2Rules: {
+        'boolean-parameter-prefixes': 'off',
+        'info-contact': 'off',
+        'info-license': 'off',
+        'info-license-strict': 'off',
+        'no-ambiguous-paths': 'off',
+        'no-duplicated-tag-names': 'error',
+        'no-enum-type-mismatch': 'off',
+        'no-http-verbs-in-paths': 'off',
+        'no-identical-paths': 'error',
+        'no-invalid-parameter-examples': 'off',
+        'no-invalid-schema-examples': 'off',
+        'no-path-trailing-slash': 'off',
+        'no-required-schema-properties-undefined': 'off',
+        'no-schema-type-mismatch': 'off',
+        'operation-2xx-response': 'off',
+        'operation-4xx-response': 'off',
+        'operation-description': 'off',
+        'operation-operationId': 'off',
+        'operation-operationId-unique': 'error',
+        'operation-operationId-url-safe': 'off',
+        'operation-parameters-unique': 'error',
+        'operation-singular-tag': 'off',
+        'operation-summary': 'off',
+        'operation-tag-defined': 'off',
+        'parameter-description': 'off',
+        'path-declaration-must-exist': 'error',
+        'path-http-verbs-order': 'off',
+        'path-not-include-query': 'error',
+        'path-params-defined': 'off',
+        'path-parameters-defined': 'error',
+        'path-segment-plural': 'off',
+        'paths-kebab-case': 'off',
+        'request-mime-type': 'off',
+        'required-string-property-missing-min-length': 'off',
+        'response-contains-header': 'off',
+        'response-contains-property': 'off',
+        'response-mime-type': 'off',
+        'scalar-property-missing-example': 'off',
+        'security-defined': 'off',
+        'spec-strict-refs': 'error',
+        'tag-description': 'off',
+        'tags-alphabetical': 'off',
+    },
+    oas3_0Rules: {
+        'array-parameter-serialization': 'off',
+        'boolean-parameter-prefixes': 'off',
+        'component-name-unique': 'off',
+        'info-contact': 'off',
+        'info-license': 'off',
+        'info-license-strict': 'off',
+        'no-ambiguous-paths': 'off',
+        'no-duplicated-tag-names': 'error',
+        'no-empty-servers': 'off',
+        'no-enum-type-mismatch': 'off',
+        'no-example-value-and-externalValue': 'error',
+        'no-http-verbs-in-paths': 'off',
+        'no-identical-paths': 'error',
+        'no-invalid-media-type-examples': {
+            severity: 'off',
+            allowAdditionalProperties: false,
+        },
+        'no-invalid-parameter-examples': 'off',
+        'no-invalid-schema-examples': 'off',
+        'no-path-trailing-slash': 'off',
+        'no-required-schema-properties-undefined': 'off',
+        'no-schema-type-mismatch': 'off',
+        'no-server-example.com': 'off',
+        'no-server-trailing-slash': 'off',
+        'no-server-variables-empty-enum': 'off',
+        'no-undefined-server-variable': 'error',
+        'no-unused-components': 'off',
+        'nullable-type-sibling': 'error',
+        'operation-2xx-response': 'off',
+        'operation-4xx-problem-details-rfc7807': 'off',
+        'operation-4xx-response': 'off',
+        'operation-description': 'off',
+        'operation-operationId': 'off',
+        'operation-operationId-unique': 'error',
+        'operation-operationId-url-safe': 'off',
+        'operation-parameters-unique': 'error',
+        'operation-singular-tag': 'off',
+        'operation-summary': 'off',
+        'operation-tag-defined': 'off',
+        'parameter-description': 'off',
+        'path-declaration-must-exist': 'error',
+        'path-http-verbs-order': 'off',
+        'path-not-include-query': 'error',
+        'path-params-defined': 'off',
+        'path-parameters-defined': 'error',
+        'path-segment-plural': 'off',
+        'paths-kebab-case': 'off',
+        'request-mime-type': 'off',
+        'required-string-property-missing-min-length': 'off',
+        'response-contains-header': 'off',
+        'response-contains-property': 'off',
+        'response-mime-type': 'off',
+        'scalar-property-missing-example': 'off',
+        'security-defined': 'off',
+        'spec-components-invalid-map-name': 'error',
+        'spec-example-values': 'off',
+        'spec-strict-refs': 'error',
+        'tag-description': 'off',
+        'tags-alphabetical': 'off',
+    },
+    oas3_1Rules: {
+        'array-parameter-serialization': 'off',
+        'boolean-parameter-prefixes': 'off',
+        'component-name-unique': 'off',
+        'info-contact': 'off',
+        'info-license': 'off',
+        'info-license-strict': 'off',
+        'no-ambiguous-paths': 'off',
+        'no-duplicated-tag-names': 'error',
+        'no-empty-servers': 'off',
+        'no-enum-type-mismatch': 'off',
+        'no-example-value-and-externalValue': 'error',
+        'no-http-verbs-in-paths': 'off',
+        'no-identical-paths': 'error',
+        'no-invalid-media-type-examples': 'off',
+        'no-invalid-parameter-examples': 'off',
+        'no-invalid-schema-examples': 'off',
+        'no-path-trailing-slash': 'off',
+        'no-required-schema-properties-undefined': 'off',
+        'no-schema-type-mismatch': 'off',
+        'no-server-example.com': 'off',
+        'no-server-trailing-slash': 'off',
+        'no-server-variables-empty-enum': 'off',
+        'no-undefined-server-variable': 'error',
+        'no-unused-components': 'off',
+        'operation-2xx-response': 'off',
+        'operation-4xx-problem-details-rfc7807': 'off',
+        'operation-4xx-response': 'off',
+        'operation-description': 'off',
+        'operation-operationId': 'off',
+        'operation-operationId-unique': 'error',
+        'operation-operationId-url-safe': 'off',
+        'operation-parameters-unique': 'error',
+        'operation-singular-tag': 'off',
+        'operation-summary': 'off',
+        'operation-tag-defined': 'off',
+        'parameter-description': 'off',
+        'path-declaration-must-exist': 'error',
+        'path-http-verbs-order': 'off',
+        'path-not-include-query': 'error',
+        'path-params-defined': 'off',
+        'path-parameters-defined': 'error',
+        'path-segment-plural': 'off',
+        'paths-kebab-case': 'off',
+        'request-mime-type': 'off',
+        'required-string-property-missing-min-length': 'off',
+        'response-contains-header': 'off',
+        'response-contains-property': 'off',
+        'response-mime-type': 'off',
+        'scalar-property-missing-example': 'off',
+        'security-defined': 'off',
+        'spec-components-invalid-map-name': 'error',
+        'spec-example-values': 'off',
+        'spec-strict-refs': 'error',
+        'tag-description': 'off',
+        'tags-alphabetical': 'off',
+    },
+    oas3_2Rules: {
+        'array-parameter-serialization': 'off',
+        'boolean-parameter-prefixes': 'off',
+        'component-name-unique': 'off',
+        'info-contact': 'off',
+        'info-license': 'off',
+        'info-license-strict': 'off',
+        'no-ambiguous-paths': 'off',
+        'no-duplicated-tag-names': 'error',
+        'no-empty-servers': 'off',
+        'no-enum-type-mismatch': 'off',
+        'no-http-verbs-in-paths': 'off',
+        'no-identical-paths': 'error',
+        'no-invalid-media-type-examples': 'off',
+        'no-invalid-parameter-examples': 'off',
+        'no-invalid-schema-examples': 'off',
+        'no-path-trailing-slash': 'off',
+        'no-required-schema-properties-undefined': 'off',
+        'no-schema-type-mismatch': 'off',
+        'no-server-example.com': 'off',
+        'no-server-trailing-slash': 'off',
+        'no-server-variables-empty-enum': 'off',
+        'no-undefined-server-variable': 'error',
+        'no-unused-components': 'off',
+        'operation-2xx-response': 'off',
+        'operation-4xx-problem-details-rfc7807': 'off',
+        'operation-4xx-response': 'off',
+        'operation-description': 'off',
+        'operation-operationId': 'off',
+        'operation-operationId-unique': 'error',
+        'operation-operationId-url-safe': 'off',
+        'operation-parameters-unique': 'error',
+        'operation-singular-tag': 'off',
+        'operation-summary': 'off',
+        'operation-tag-defined': 'off',
+        'parameter-description': 'off',
+        'path-declaration-must-exist': 'error',
+        'path-http-verbs-order': 'off',
+        'path-not-include-query': 'error',
+        'path-params-defined': 'off',
+        'path-parameters-defined': 'error',
+        'path-segment-plural': 'off',
+        'paths-kebab-case': 'off',
+        'request-mime-type': 'off',
+        'required-string-property-missing-min-length': 'off',
+        'response-contains-header': 'off',
+        'response-contains-property': 'off',
+        'response-mime-type': 'off',
+        'scalar-property-missing-example': 'off',
+        'security-defined': 'off',
+        'spec-components-invalid-map-name': 'error',
+        'spec-discriminator-defaultMapping': 'error',
+        'spec-example-values': 'error',
+        'spec-no-invalid-encoding-combinations': 'error',
+        'spec-no-invalid-tag-parents': 'error',
+        'spec-querystring-parameters': 'error',
+        'spec-strict-refs': 'error',
+        'tag-description': 'off',
+        'tags-alphabetical': 'off',
+    },
+    async2Rules: {
+        'channels-kebab-case': 'off',
+        'info-contact': 'off',
+        'info-license-strict': 'off',
+        'no-channel-trailing-slash': 'off',
+        'no-duplicated-tag-names': 'off',
+        'no-enum-type-mismatch': 'off',
+        'no-required-schema-properties-undefined': 'off',
+        'no-schema-type-mismatch': 'off',
+        'operation-operationId': 'off',
+        'tag-description': 'off',
+        'tags-alphabetical': 'off',
+    },
+    async3Rules: {
+        'channels-kebab-case': 'off',
+        'info-contact': 'off',
+        'info-license-strict': 'off',
+        'no-channel-trailing-slash': 'off',
+        'no-duplicated-tag-names': 'off',
+        'no-enum-type-mismatch': 'off',
+        'no-required-schema-properties-undefined': 'off',
+        'no-schema-type-mismatch': 'off',
+        'operation-operationId': 'off',
+        'tag-description': 'off',
+        'tags-alphabetical': 'off',
+    },
+    arazzo1Rules: {
+        'criteria-unique': 'error',
+        'no-criteria-xpath': 'off',
+        'no-enum-type-mismatch': 'off',
+        'no-required-schema-properties-undefined': 'off',
+        'no-schema-type-mismatch': 'off',
+        'no-x-security-both-scheme-and-scheme-name': 'off',
+        'no-x-security-scheme-name-without-openapi': 'off',
+        'outputs-defined': 'error',
+        'parameters-unique': 'error',
+        'requestBody-replacements-unique': 'error',
+        'respect-supported-versions': 'off',
+        'sourceDescription-name-unique': 'error',
+        'sourceDescription-type': 'error',
+        'sourceDescriptions-not-empty': 'error',
+        'step-onFailure-unique': 'error',
+        'step-onSuccess-unique': 'error',
+        'stepId-unique': 'error',
+        'workflow-dependsOn': 'error',
+        'workflowId-unique': 'error',
+        'x-security-scheme-name-reference': 'off',
+        'x-security-scheme-required-values': 'off',
+    },
+    overlay1Rules: {
+        'info-contact': 'off',
+    },
+    openrpc1Rules: {
+        'info-contact': 'off',
+        'info-license': 'off',
+        'no-unused-components': 'off',
+        'spec-no-duplicated-method-params': 'error',
+        'spec-no-required-params-after-optional': 'error',
+    },
+};
+export default spec;
+//# sourceMappingURL=spec.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,129 @@
+import { assignOnlyExistingConfig, assignConfig } from '../utils/assign-config.js';
+import { isPlainObject } from '../utils/is-plain-object.js';
+export function parsePresetName(presetName) {
+    if (presetName.indexOf('/') > -1) {
+        const [pluginId, configName] = presetName.split('/');
+        return { pluginId, configName };
+    }
+    else {
+        return { pluginId: '', configName: presetName };
+    }
+}
+export function prefixRules(rules, prefix) {
+    if (!prefix)
+        return rules;
+    const res = {};
+    for (const name of Object.keys(rules)) {
+        res[`${prefix}/${name}`] = rules[name];
+    }
+    return res;
+}
+export function mergeExtends(rulesConfList) {
+    const result = {
+        rules: {},
+        oas2Rules: {},
+        oas3_0Rules: {},
+        oas3_1Rules: {},
+        oas3_2Rules: {},
+        async2Rules: {},
+        async3Rules: {},
+        arazzo1Rules: {},
+        overlay1Rules: {},
+        openrpc1Rules: {},
+        preprocessors: {},
+        oas2Preprocessors: {},
+        oas3_0Preprocessors: {},
+        oas3_1Preprocessors: {},
+        oas3_2Preprocessors: {},
+        async2Preprocessors: {},
+        async3Preprocessors: {},
+        arazzo1Preprocessors: {},
+        overlay1Preprocessors: {},
+        openrpc1Preprocessors: {},
+        decorators: {},
+        oas2Decorators: {},
+        oas3_0Decorators: {},
+        oas3_1Decorators: {},
+        oas3_2Decorators: {},
+        async2Decorators: {},
+        async3Decorators: {},
+        arazzo1Decorators: {},
+        overlay1Decorators: {},
+        openrpc1Decorators: {},
+    };
+    for (const rulesConf of rulesConfList) {
+        if (isPlainObject(rulesConf) && 'extends' in rulesConf && rulesConf.extends !== undefined) {
+            throw new Error(`'extends' is not supported in shared configs yet:\n${JSON.stringify(rulesConf, null, 2)}`);
+        }
+        assignConfig(result.rules, rulesConf.rules);
+        assignConfig(result.oas2Rules, rulesConf.oas2Rules);
+        assignOnlyExistingConfig(result.oas2Rules, rulesConf.rules);
+        assignConfig(result.oas3_0Rules, rulesConf.oas3_0Rules);
+        assignOnlyExistingConfig(result.oas3_0Rules, rulesConf.rules);
+        assignConfig(result.oas3_1Rules, rulesConf.oas3_1Rules);
+        assignOnlyExistingConfig(result.oas3_1Rules, rulesConf.rules);
+        assignConfig(result.oas3_2Rules, rulesConf.oas3_2Rules);
+        assignOnlyExistingConfig(result.oas3_2Rules, rulesConf.rules);
+        assignConfig(result.async2Rules, rulesConf.async2Rules);
+        assignOnlyExistingConfig(result.async2Rules, rulesConf.rules);
+        assignConfig(result.async3Rules, rulesConf.async3Rules);
+        assignOnlyExistingConfig(result.async3Rules, rulesConf.rules);
+        assignConfig(result.arazzo1Rules, rulesConf.arazzo1Rules);
+        assignOnlyExistingConfig(result.arazzo1Rules, rulesConf.rules);
+        assignConfig(result.overlay1Rules, rulesConf.overlay1Rules);
+        assignOnlyExistingConfig(result.overlay1Rules, rulesConf.rules);
+        assignConfig(result.openrpc1Rules, rulesConf.openrpc1Rules);
+        assignOnlyExistingConfig(result.openrpc1Rules, rulesConf.rules);
+        assignConfig(result.preprocessors, rulesConf.preprocessors);
+        assignConfig(result.oas2Preprocessors, rulesConf.oas2Preprocessors);
+        assignOnlyExistingConfig(result.oas2Preprocessors, rulesConf.preprocessors);
+        assignConfig(result.oas3_0Preprocessors, rulesConf.oas3_0Preprocessors);
+        assignOnlyExistingConfig(result.oas3_0Preprocessors, rulesConf.preprocessors);
+        assignConfig(result.oas3_1Preprocessors, rulesConf.oas3_1Preprocessors);
+        assignOnlyExistingConfig(result.oas3_1Preprocessors, rulesConf.preprocessors);
+        assignConfig(result.oas3_2Preprocessors, rulesConf.oas3_2Preprocessors);
+        assignOnlyExistingConfig(result.oas3_2Preprocessors, rulesConf.preprocessors);
+        assignConfig(result.async2Preprocessors, rulesConf.async2Preprocessors);
+        assignOnlyExistingConfig(result.async2Preprocessors, rulesConf.preprocessors);
+        assignConfig(result.async3Preprocessors, rulesConf.async3Preprocessors);
+        assignOnlyExistingConfig(result.async3Preprocessors, rulesConf.preprocessors);
+        assignConfig(result.arazzo1Preprocessors, rulesConf.arazzo1Preprocessors);
+        assignOnlyExistingConfig(result.arazzo1Preprocessors, rulesConf.preprocessors);
+        assignConfig(result.overlay1Preprocessors, rulesConf.overlay1Preprocessors);
+        assignOnlyExistingConfig(result.overlay1Preprocessors, rulesConf.preprocessors);
+        assignConfig(result.openrpc1Preprocessors, rulesConf.openrpc1Preprocessors);
+        assignOnlyExistingConfig(result.openrpc1Preprocessors, rulesConf.preprocessors);
+        assignConfig(result.decorators, rulesConf.decorators);
+        assignConfig(result.oas2Decorators, rulesConf.oas2Decorators);
+        assignOnlyExistingConfig(result.oas2Decorators, rulesConf.decorators);
+        assignConfig(result.oas3_0Decorators, rulesConf.oas3_0Decorators);
+        assignOnlyExistingConfig(result.oas3_0Decorators, rulesConf.decorators);
+        assignConfig(result.oas3_1Decorators, rulesConf.oas3_1Decorators);
+        assignOnlyExistingConfig(result.oas3_1Decorators, rulesConf.decorators);
+        assignConfig(result.oas3_2Decorators, rulesConf.oas3_2Decorators);
+        assignOnlyExistingConfig(result.oas3_2Decorators, rulesConf.decorators);
+        assignConfig(result.async2Decorators, rulesConf.async2Decorators);
+        assignOnlyExistingConfig(result.async2Decorators, rulesConf.decorators);
+        assignConfig(result.async3Decorators, rulesConf.async3Decorators);
+        assignOnlyExistingConfig(result.async3Decorators, rulesConf.decorators);
+        assignConfig(result.arazzo1Decorators, rulesConf.arazzo1Decorators);
+        assignOnlyExistingConfig(result.arazzo1Decorators, rulesConf.decorators);
+        assignConfig(result.overlay1Decorators, rulesConf.overlay1Decorators);
+        assignOnlyExistingConfig(result.overlay1Decorators, rulesConf.decorators);
+        assignConfig(result.openrpc1Decorators, rulesConf.openrpc1Decorators);
+        assignOnlyExistingConfig(result.openrpc1Decorators, rulesConf.decorators);
+    }
+    return result;
+}
+export class ConfigValidationError extends Error {
+}
+export function deepCloneMapWithJSON(originalMap) {
+    return new Map(JSON.parse(JSON.stringify([...originalMap])));
+}
+export function isDeprecatedPluginFormat(plugin) {
+    return isPlainObject(plugin) && 'id' in plugin;
+}
+export function isCommonJsPlugin(plugin) {
+    return typeof plugin === 'function';
+}
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,99 @@
+import * as redoclyConfig from '@redocly/config';
+import { replaceRef } from '../ref-utils.js';
+import { NormalizedConfigTypes } from '../types/redocly-yaml.js';
+import { isPlainObject } from '../utils/is-plain-object.js';
+import { normalizeVisitors } from '../visitors.js';
+import { bundleExtends } from './bundle-extends.js';
+import { preResolvePluginPath } from './config-resolvers.js';
+import { CONFIG_BUNDLER_VISITOR_ID, PLUGINS_COLLECTOR_VISITOR_ID } from './constants.js';
+function collectorHandleNode(node, ctx) {
+    if (isPlainObject(node) && Array.isArray(node.plugins)) {
+        const { plugins, rootConfigDir } = ctx.getVisitorData();
+        plugins.push(...node.plugins.map((p) => {
+            return preResolvePluginPath(p, ctx.location.source.absoluteRef.replace(/^file:\/\//, ''), // remove file URL prefix for OpenAPI language server
+            rootConfigDir);
+        }));
+    }
+}
+export const pluginsCollectorVisitor = normalizeVisitors([
+    {
+        severity: 'error',
+        ruleId: PLUGINS_COLLECTOR_VISITOR_ID,
+        visitor: {
+            ref: {},
+            ConfigGovernance: {
+                leave(node, ctx) {
+                    collectorHandleNode(node, ctx);
+                },
+            },
+            ConfigApisProperties: {
+                leave(node, ctx) {
+                    collectorHandleNode(node, ctx);
+                },
+            },
+            [redoclyConfig.CONFIG_NODE_TYPE_NAMES.ScorecardClassicLevel]: {
+                leave(node, ctx) {
+                    collectorHandleNode(node, ctx);
+                },
+            },
+            'rootRedoclyConfigSchema.scorecardClassic.levels_items': {
+                leave(node, ctx) {
+                    collectorHandleNode(node, ctx);
+                },
+            },
+            ConfigRoot: {
+                leave(node, ctx) {
+                    collectorHandleNode(node, ctx);
+                },
+            },
+        },
+    },
+], NormalizedConfigTypes);
+function bundlerHandleNode(node, ctx) {
+    if (isPlainObject(node) && node.extends) {
+        const { plugins } = ctx.getVisitorData();
+        const bundled = bundleExtends({ node, ctx, plugins });
+        Object.assign(node, bundled);
+        delete node.extends;
+    }
+}
+export const configBundlerVisitor = normalizeVisitors([
+    {
+        severity: 'error',
+        ruleId: CONFIG_BUNDLER_VISITOR_ID,
+        visitor: {
+            ref: {
+                leave(node, ctx, resolved) {
+                    replaceRef(node, resolved, ctx);
+                },
+            },
+            ConfigGovernance: {
+                leave(node, ctx) {
+                    bundlerHandleNode(node, ctx);
+                },
+            },
+            ConfigApisProperties: {
+                leave(node, ctx) {
+                    // ignore extends from root config if defined in the current node
+                    bundlerHandleNode(node, ctx);
+                },
+            },
+            [redoclyConfig.CONFIG_NODE_TYPE_NAMES.ScorecardClassicLevel]: {
+                leave(node, ctx) {
+                    bundlerHandleNode(node, ctx);
+                },
+            },
+            'rootRedoclyConfigSchema.scorecardClassic.levels_items': {
+                leave(node, ctx) {
+                    bundlerHandleNode(node, ctx);
+                },
+            },
+            ConfigRoot: {
+                leave(node, ctx) {
+                    bundlerHandleNode(node, ctx);
+                },
+            },
+        },
+    },
+], NormalizedConfigTypes);
+//# sourceMappingURL=visitors.js.map

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

@@ -0,0 +1,2 @@
+export const decorators = {};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/decorators/async2/index.js

@@ -0,0 +1,2 @@
+export const decorators = {};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/decorators/async3/index.js

@@ -0,0 +1,2 @@
+export const decorators = {};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/decorators/common/filters/filter-helper.js

@@ -0,0 +1,65 @@
+import { isRef } from '../../../ref-utils.js';
+import { isEmptyArray } from '../../../utils/is-empty-array.js';
+import { isEmptyObject } from '../../../utils/is-empty-object.js';
+import { isPlainObject } from '../../../utils/is-plain-object.js';
+export function filter(node, ctx, criteria) {
+    const { parent, key } = ctx;
+    let didDelete = false;
+    if (Array.isArray(node)) {
+        for (let i = 0; i < node.length; i++) {
+            if (isRef(node[i])) {
+                const resolved = ctx.resolve(node[i]);
+                if (criteria(resolved.node)) {
+                    node.splice(i, 1);
+                    didDelete = true;
+                    i--;
+                }
+            }
+            if (criteria(node[i])) {
+                node.splice(i, 1);
+                didDelete = true;
+                i--;
+            }
+        }
+    }
+    else if (isPlainObject(node)) {
+        for (const key of Object.keys(node)) {
+            node = node;
+            if (isRef(node[key])) {
+                const resolved = ctx.resolve(node[key]);
+                if (criteria(resolved.node)) {
+                    delete node[key];
+                    didDelete = true;
+                }
+            }
+            if (criteria(node[key])) {
+                delete node[key];
+                didDelete = true;
+            }
+        }
+    }
+    if (didDelete && (isEmptyObject(node) || isEmptyArray(node))) {
+        delete parent[key];
+    }
+}
+export function checkIfMatchByStrategy(nodeValue, decoratorValue, strategy) {
+    if (nodeValue === undefined || decoratorValue === undefined) {
+        return false;
+    }
+    if (!Array.isArray(decoratorValue) && !Array.isArray(nodeValue)) {
+        return nodeValue === decoratorValue;
+    }
+    decoratorValue = toArrayIfNeeded(decoratorValue);
+    nodeValue = toArrayIfNeeded(nodeValue);
+    if (strategy === 'any') {
+        return decoratorValue.some((item) => nodeValue.includes(item));
+    }
+    if (strategy === 'all') {
+        return decoratorValue.every((item) => nodeValue.includes(item));
+    }
+    return false;
+}
+function toArrayIfNeeded(value) {
+    return Array.isArray(value) ? value : [value];
+}
+//# sourceMappingURL=filter-helper.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/decorators/common/filters/filter-in.js

@@ -0,0 +1,14 @@
+import { checkIfMatchByStrategy, filter } from './filter-helper.js';
+const DEFAULT_STRATEGY = 'any';
+export const FilterIn = ({ property, value, matchStrategy }) => {
+    const strategy = matchStrategy || DEFAULT_STRATEGY;
+    const filterInCriteria = (item) => item?.[property] && !checkIfMatchByStrategy(item?.[property], value, strategy);
+    return {
+        any: {
+            enter: (node, ctx) => {
+                filter(node, ctx, filterInCriteria);
+            },
+        },
+    };
+};
+//# sourceMappingURL=filter-in.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/decorators/common/filters/filter-out.js

@@ -0,0 +1,14 @@
+import { checkIfMatchByStrategy, filter } from './filter-helper.js';
+const DEFAULT_STRATEGY = 'any';
+export const FilterOut = ({ property, value, matchStrategy }) => {
+    const strategy = matchStrategy || DEFAULT_STRATEGY;
+    const filterOutCriteria = (item) => checkIfMatchByStrategy(item?.[property], value, strategy);
+    return {
+        any: {
+            enter: (node, ctx) => {
+                filter(node, ctx, filterOutCriteria);
+            },
+        },
+    };
+};
+//# sourceMappingURL=filter-out.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/decorators/common/info-description-override.js

@@ -0,0 +1,21 @@
+import { readFileAsStringSync, resolveRelativePath } from '../../utils/yaml-fs-helper.js';
+export const InfoDescriptionOverride = ({ filePath }) => {
+    return {
+        Info: {
+            leave(info, { report, location, config }) {
+                if (!filePath)
+                    throw new Error(`Parameter "filePath" is not provided for "info-description-override" rule`);
+                try {
+                    info.description = readFileAsStringSync(resolveRelativePath(filePath, config?.configPath));
+                }
+                catch (e) {
+                    report({
+                        message: `Failed to read markdown override file for "info.description".\n${e.message}`,
+                        location: location.child('description'),
+                    });
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=info-description-override.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/decorators/common/info-override.js

@@ -0,0 +1,14 @@
+export const InfoOverride = (newInfo) => {
+    return {
+        Info: {
+            leave(info) {
+                if (typeof newInfo !== 'object' || Array.isArray(newInfo) || newInfo === null) {
+                    throw new Error(`"info-override" decorator should be called with an object`);
+                }
+                const { severity: _, ...rest } = newInfo;
+                Object.assign(info, rest);
+            },
+        },
+    };
+};
+//# sourceMappingURL=info-override.js.map