@kubb/agent 4.33.1 → 4.33.3

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

@@ -0,0 +1,67 @@
+import { isRef } from '../../../ref-utils.js';
+import { isPlainObject } from '../../../utils/is-plain-object.js';
+import { checkIfMatchByStrategy, filter } from './filter-helper.js';
+const DEFAULT_STRATEGY = 'any';
+export const FilterOut = ({ property, value, matchStrategy, applyTo: target, }) => {
+    const strategy = matchStrategy || DEFAULT_STRATEGY;
+    if (target !== undefined) {
+        if (target === 'Operation') {
+            const httpMethods = [
+                'get',
+                'post',
+                'put',
+                'delete',
+                'patch',
+                'options',
+                'head',
+                'trace',
+                'query',
+            ];
+            return {
+                PathItem: {
+                    enter(pathItem, ctx) {
+                        for (const method of httpMethods) {
+                            const operation = isRef(pathItem[method])
+                                ? ctx.resolve(pathItem[method]).node
+                                : pathItem[method];
+                            if (isPlainObject(operation)) {
+                                const propertyValue = operation[property];
+                                const shouldRemove = checkIfMatchByStrategy(propertyValue, value, strategy);
+                                if (shouldRemove) {
+                                    delete pathItem[method];
+                                }
+                            }
+                        }
+                        const hasOperations = httpMethods.some((method) => pathItem[method]) || pathItem.additionalOperations;
+                        if (!hasOperations) {
+                            delete ctx.parent[ctx.key];
+                        }
+                    },
+                },
+            };
+        }
+        if (target === 'PathItem') {
+            return {
+                PathItem: {
+                    enter(pathItem, ctx) {
+                        const propertyValue = pathItem[property];
+                        const shouldRemove = checkIfMatchByStrategy(propertyValue, value, strategy);
+                        if (shouldRemove) {
+                            delete ctx.parent[ctx.key];
+                        }
+                    },
+                },
+            };
+        }
+        throw new Error(`The 'target' option must be 'Operation' or 'PathItem' when provided.`);
+    }
+    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

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

@@ -0,0 +1,58 @@
+import { isRef } from '../../ref-utils.js';
+import { resolveRelativePath, yamlAndJsonSyncReader } from '../../utils/yaml-fs-helper.js';
+export const MediaTypeExamplesOverride = ({ operationIds }) => {
+    return {
+        Operation: {
+            enter(operation, ctx) {
+                const operationId = operation.operationId;
+                if (!operationId) {
+                    return;
+                }
+                const properties = operationIds[operationId];
+                if (!properties) {
+                    return;
+                }
+                if (properties.responses && operation.responses) {
+                    for (const responseCode of Object.keys(properties.responses)) {
+                        const resolvedResponse = checkAndResolveRef(operation.responses[responseCode], ctx.resolve);
+                        if (!resolvedResponse) {
+                            continue;
+                        }
+                        resolvedResponse.content = resolvedResponse.content ? resolvedResponse.content : {};
+                        Object.keys(properties.responses[responseCode]).forEach((mimeType) => {
+                            const filePath = properties.responses[responseCode][mimeType];
+                            resolvedResponse.content[mimeType] = {
+                                ...resolvedResponse.content[mimeType],
+                                examples: yamlAndJsonSyncReader(resolveRelativePath(filePath, ctx.config?.configPath)),
+                            };
+                        });
+                        operation.responses[responseCode] = resolvedResponse;
+                    }
+                }
+                if (properties.request && operation.requestBody) {
+                    const resolvedRequest = checkAndResolveRef(operation.requestBody, ctx.resolve);
+                    if (!resolvedRequest) {
+                        return;
+                    }
+                    resolvedRequest.content = resolvedRequest.content ? resolvedRequest.content : {};
+                    Object.keys(properties.request).forEach((mimeType) => {
+                        const filePath = properties.request[mimeType];
+                        resolvedRequest.content[mimeType] = {
+                            ...resolvedRequest.content[mimeType],
+                            examples: yamlAndJsonSyncReader(resolveRelativePath(filePath, ctx.config?.configPath)),
+                        };
+                    });
+                    operation.requestBody = resolvedRequest;
+                }
+            },
+        },
+    };
+};
+function checkAndResolveRef(node, resolver) {
+    if (!isRef(node)) {
+        return node;
+    }
+    const resolved = resolver(node);
+    return resolved.error ? undefined : JSON.parse(JSON.stringify(resolved.node));
+}
+//# sourceMappingURL=media-type-examples-override.js.map

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

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

package/.output/server/node_modules/@redocly/openapi-core/lib/decorators/common/remove-x-internal.js

@@ -0,0 +1,68 @@
+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';
+const DEFAULT_INTERNAL_PROPERTY_NAME = 'x-internal';
+export const RemoveXInternal = ({ internalFlagProperty = DEFAULT_INTERNAL_PROPERTY_NAME, }) => {
+    function removeInternal(node, ctx, originalMapping) {
+        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 (resolved.node?.[internalFlagProperty]) {
+                        // First, remove the reference in the discriminator mapping, if it exists:
+                        if (isPlainObject(parent.discriminator?.mapping)) {
+                            for (const mapping in parent.discriminator.mapping) {
+                                if (originalMapping?.[mapping] === node[i].$ref) {
+                                    delete parent.discriminator.mapping[mapping];
+                                }
+                            }
+                        }
+                        node.splice(i, 1);
+                        didDelete = true;
+                        i--;
+                    }
+                }
+                if (node[i]?.[internalFlagProperty]) {
+                    node.splice(i, 1);
+                    didDelete = true;
+                    i--;
+                }
+            }
+        }
+        else if (isPlainObject(node)) {
+            for (const key of Object.keys(node)) {
+                if (isRef(node[key])) {
+                    const resolved = ctx.resolve(node[key]);
+                    if (isPlainObject(resolved.node) && resolved.node?.[internalFlagProperty]) {
+                        delete node[key];
+                        didDelete = true;
+                    }
+                }
+                if (isPlainObject(node[key]) && node[key]?.[internalFlagProperty]) {
+                    delete node[key];
+                    didDelete = true;
+                }
+            }
+        }
+        if (didDelete && (isEmptyObject(node) || isEmptyArray(node))) {
+            delete parent[key];
+        }
+    }
+    let originalMapping = {};
+    return {
+        DiscriminatorMapping: {
+            enter: (mapping) => {
+                originalMapping = JSON.parse(JSON.stringify(mapping));
+            },
+        },
+        any: {
+            enter: (node, ctx) => {
+                removeInternal(node, ctx, originalMapping);
+            },
+        },
+    };
+};
+//# sourceMappingURL=remove-x-internal.js.map

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

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

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

@@ -0,0 +1,19 @@
+import { FilterIn } from '../common/filters/filter-in.js';
+import { FilterOut } from '../common/filters/filter-out.js';
+import { InfoDescriptionOverride } from '../common/info-description-override.js';
+import { InfoOverride } from '../common/info-override.js';
+import { OperationDescriptionOverride } from '../common/operation-description-override.js';
+import { RemoveXInternal } from '../common/remove-x-internal.js';
+import { TagDescriptionOverride } from '../common/tag-description-override.js';
+import { RemoveUnusedComponents } from './remove-unused-components.js';
+export const decorators = {
+    'operation-description-override': OperationDescriptionOverride,
+    'tag-description-override': TagDescriptionOverride,
+    'info-description-override': InfoDescriptionOverride,
+    'info-override': InfoOverride,
+    'remove-x-internal': RemoveXInternal,
+    'filter-in': FilterIn,
+    'filter-out': FilterOut,
+    'remove-unused-components': RemoveUnusedComponents, // always the last one
+};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/decorators/oas2/remove-unused-components.js

@@ -0,0 +1,88 @@
+import { isEmptyObject } from '../../utils/is-empty-object.js';
+export const RemoveUnusedComponents = () => {
+    const components = new Map();
+    function registerComponent(location, componentType, name) {
+        components.set(location.absolutePointer, {
+            usedIn: components.get(location.absolutePointer)?.usedIn ?? [],
+            componentType,
+            name,
+        });
+    }
+    function removeUnusedComponents(root, removedPaths) {
+        const removedLengthStart = removedPaths.length;
+        for (const [path, { usedIn, name, componentType }] of components) {
+            const used = usedIn.some((location) => !removedPaths.some((removed) => 
+            // Check if the current location's absolute pointer starts with the 'removed' path
+            // and either its length matches exactly with 'removed' or the character after the 'removed' path is a '/'
+            location.absolutePointer.startsWith(removed) &&
+                (location.absolutePointer.length === removed.length ||
+                    location.absolutePointer[removed.length] === '/')));
+            if (!used && componentType) {
+                removedPaths.push(path);
+                delete root[componentType][name];
+                components.delete(path);
+                if (isEmptyObject(root[componentType])) {
+                    delete root[componentType];
+                }
+            }
+        }
+        return removedPaths.length > removedLengthStart
+            ? removeUnusedComponents(root, removedPaths)
+            : removedPaths.length;
+    }
+    return {
+        ref: {
+            leave(ref, { location, type, resolve, key }) {
+                if (['Schema', 'Parameter', 'Response', 'SecurityScheme'].includes(type.name)) {
+                    const resolvedRef = resolve(ref);
+                    if (!resolvedRef.location)
+                        return;
+                    const [fileLocation, localPointer] = resolvedRef.location.absolutePointer.split('#', 2);
+                    if (!localPointer)
+                        return;
+                    const componentLevelLocalPointer = localPointer.split('/').slice(0, 3).join('/');
+                    const pointer = `${fileLocation}#${componentLevelLocalPointer}`;
+                    const registered = components.get(pointer);
+                    if (registered) {
+                        registered.usedIn.push(location);
+                    }
+                    else {
+                        components.set(pointer, {
+                            usedIn: [location],
+                            name: key.toString(),
+                        });
+                    }
+                }
+            },
+        },
+        Root: {
+            leave(root, ctx) {
+                const data = ctx.getVisitorData();
+                data.removedCount = removeUnusedComponents(root, []);
+            },
+        },
+        NamedSchemas: {
+            Schema(schema, { location, key }) {
+                if (!schema.allOf) {
+                    registerComponent(location, 'definitions', key.toString());
+                }
+            },
+        },
+        NamedParameters: {
+            Parameter(_parameter, { location, key }) {
+                registerComponent(location, 'parameters', key.toString());
+            },
+        },
+        NamedResponses: {
+            Response(_response, { location, key }) {
+                registerComponent(location, 'responses', key.toString());
+            },
+        },
+        NamedSecuritySchemes: {
+            SecurityScheme(_securityScheme, { location, key }) {
+                registerComponent(location, 'securityDefinitions', key.toString());
+            },
+        },
+    };
+};
+//# sourceMappingURL=remove-unused-components.js.map

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

@@ -0,0 +1,21 @@
+import { FilterIn } from '../common/filters/filter-in.js';
+import { FilterOut } from '../common/filters/filter-out.js';
+import { InfoDescriptionOverride } from '../common/info-description-override.js';
+import { InfoOverride } from '../common/info-override.js';
+import { MediaTypeExamplesOverride } from '../common/media-type-examples-override.js';
+import { OperationDescriptionOverride } from '../common/operation-description-override.js';
+import { RemoveXInternal } from '../common/remove-x-internal.js';
+import { TagDescriptionOverride } from '../common/tag-description-override.js';
+import { RemoveUnusedComponents } from './remove-unused-components.js';
+export const decorators = {
+    'operation-description-override': OperationDescriptionOverride,
+    'tag-description-override': TagDescriptionOverride,
+    'info-description-override': InfoDescriptionOverride,
+    'info-override': InfoOverride,
+    'remove-x-internal': RemoveXInternal,
+    'filter-in': FilterIn,
+    'filter-out': FilterOut,
+    'media-type-examples-override': MediaTypeExamplesOverride,
+    'remove-unused-components': RemoveUnusedComponents, // always the last one
+};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/decorators/oas3/remove-unused-components.js

@@ -0,0 +1,116 @@
+import { isEmptyObject } from '../../utils/is-empty-object.js';
+import { hasComponent } from '../../utils/oas-has-component.js';
+export const RemoveUnusedComponents = () => {
+    const components = new Map();
+    function registerComponent(location, componentType, name) {
+        components.set(location.absolutePointer, {
+            usedIn: components.get(location.absolutePointer)?.usedIn ?? [],
+            componentType,
+            name,
+        });
+    }
+    function removeUnusedComponents(root, removedPaths) {
+        const removedLengthStart = removedPaths.length;
+        for (const [path, { usedIn, name, componentType }] of components) {
+            const used = usedIn.some((location) => !removedPaths.some((removed) => location.absolutePointer.startsWith(removed) &&
+                (location.absolutePointer.length === removed.length ||
+                    location.absolutePointer[removed.length] === '/')));
+            if (!used &&
+                componentType &&
+                root.components &&
+                hasComponent(root.components, componentType)) {
+                removedPaths.push(path);
+                const componentChild = root.components[componentType];
+                delete componentChild[name];
+                components.delete(path);
+                if (isEmptyObject(componentChild)) {
+                    delete root.components[componentType];
+                }
+            }
+        }
+        return removedPaths.length > removedLengthStart
+            ? removeUnusedComponents(root, removedPaths)
+            : removedPaths.length;
+    }
+    return {
+        ref: {
+            leave(ref, { location, type, resolve, key }) {
+                if ([
+                    'Schema',
+                    'Header',
+                    'Parameter',
+                    'Response',
+                    'Example',
+                    'RequestBody',
+                    'MediaTypesMap',
+                ].includes(type.name)) {
+                    const resolvedRef = resolve(ref);
+                    if (!resolvedRef.location)
+                        return;
+                    const [fileLocation, localPointer] = resolvedRef.location.absolutePointer.split('#', 2);
+                    if (!localPointer)
+                        return;
+                    const componentLevelLocalPointer = localPointer.split('/').slice(0, 4).join('/');
+                    const pointer = `${fileLocation}#${componentLevelLocalPointer}`;
+                    const registered = components.get(pointer);
+                    if (registered) {
+                        registered.usedIn.push(location);
+                    }
+                    else {
+                        components.set(pointer, {
+                            usedIn: [location],
+                            name: key.toString(),
+                        });
+                    }
+                }
+            },
+        },
+        Root: {
+            leave(root, ctx) {
+                const data = ctx.getVisitorData();
+                data.removedCount = removeUnusedComponents(root, []);
+                if (isEmptyObject(root.components)) {
+                    delete root.components;
+                }
+            },
+        },
+        NamedSchemas: {
+            Schema(schema, { location, key }) {
+                if (!schema.allOf) {
+                    registerComponent(location, 'schemas', key.toString());
+                }
+            },
+        },
+        NamedParameters: {
+            Parameter(_parameter, { location, key }) {
+                registerComponent(location, 'parameters', key.toString());
+            },
+        },
+        NamedResponses: {
+            Response(_response, { location, key }) {
+                registerComponent(location, 'responses', key.toString());
+            },
+        },
+        NamedExamples: {
+            Example(_example, { location, key }) {
+                registerComponent(location, 'examples', key.toString());
+            },
+        },
+        NamedRequestBodies: {
+            RequestBody(_requestBody, { location, key }) {
+                registerComponent(location, 'requestBodies', key.toString());
+            },
+        },
+        NamedHeaders: {
+            Header(_header, { location, key }) {
+                registerComponent(location, 'headers', key.toString());
+            },
+        },
+        NamedMediaTypes: {
+            MediaTypesMap(_mediaTypesMap, { location, key }) {
+                registerComponent(location, 'mediaTypes', key.toString());
+            },
+        },
+    };
+};
+//# sourceMappingURL=remove-unused-components.js.map

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

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

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

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

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

@@ -0,0 +1,79 @@
+import { VERSION_PATTERN } from './typings/arazzo.js';
+import { isPlainObject } from './utils/is-plain-object.js';
+export const specVersions = [
+    'oas2',
+    'oas3_0',
+    'oas3_1',
+    'oas3_2',
+    'async2',
+    'async3',
+    'arazzo1',
+    'overlay1',
+    'openrpc1',
+];
+export function getMajorSpecVersion(version) {
+    if (version === 'oas2') {
+        return 'oas2';
+    }
+    else if (version === 'async2') {
+        return 'async2';
+    }
+    else if (version === 'async3') {
+        return 'async3';
+    }
+    else if (version === 'arazzo1') {
+        return 'arazzo1';
+    }
+    else if (version === 'overlay1') {
+        return 'overlay1';
+    }
+    else if (version === 'openrpc1') {
+        return 'openrpc1';
+    }
+    else {
+        return 'oas3';
+    }
+}
+export function detectSpec(root) {
+    if (!isPlainObject(root)) {
+        throw new Error(`Document must be JSON object, got ${typeof root}`);
+    }
+    if (typeof root.openrpc === 'string' && root.openrpc.startsWith('1.')) {
+        return 'openrpc1';
+    }
+    if (root.openapi && typeof root.openapi !== 'string') {
+        throw new Error(`Invalid OpenAPI version: should be a string but got "${typeof root.openapi}"`);
+    }
+    if (typeof root.openapi === 'string' && root.openapi.startsWith('3.0.')) {
+        return 'oas3_0';
+    }
+    if (typeof root.openapi === 'string' && root.openapi.startsWith('3.1.')) {
+        return 'oas3_1';
+    }
+    if (typeof root.openapi === 'string' && root.openapi.startsWith('3.2.')) {
+        return 'oas3_2';
+    }
+    if (root.swagger && root.swagger === '2.0') {
+        return 'oas2';
+    }
+    if (root.openapi || root.swagger) {
+        throw new Error(`Unsupported OpenAPI version: ${root.openapi || root.swagger}`);
+    }
+    if (typeof root.asyncapi === 'string' && root.asyncapi.startsWith('2.')) {
+        return 'async2';
+    }
+    if (typeof root.asyncapi === 'string' && root.asyncapi.startsWith('3.')) {
+        return 'async3';
+    }
+    if (root.asyncapi) {
+        throw new Error(`Unsupported AsyncAPI version: ${root.asyncapi}`);
+    }
+    if (typeof root.arazzo === 'string' && VERSION_PATTERN.test(root.arazzo)) {
+        return 'arazzo1';
+    }
+    if (typeof root.overlay === 'string' && VERSION_PATTERN.test(root.overlay)) {
+        return 'overlay1';
+    }
+    throw new Error(`Unsupported specification`);
+}
+//# sourceMappingURL=detect-spec.js.map

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

@@ -0,0 +1,5 @@
+export const isBrowser = typeof window !== 'undefined' ||
+    typeof process === 'undefined' ||
+    process?.platform === 'browser'; // main and worker thread
+export const env = isBrowser ? {} : process.env || {};
+//# sourceMappingURL=env.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/errors/yaml-parse-error.js

@@ -0,0 +1,14 @@
+const jsYamlErrorLineColRegexp = /\((\d+):(\d+)\)$/;
+export class YamlParseError extends Error {
+    constructor(originalError, source) {
+        super(originalError.message.split('\n')[0]);
+        this.originalError = originalError;
+        this.source = source;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, YamlParseError.prototype);
+        const [, line, col] = this.message.match(jsYamlErrorLineColRegexp) || [];
+        this.line = parseInt(line, 10);
+        this.col = parseInt(col, 10);
+    }
+}
+//# sourceMappingURL=yaml-parse-error.js.map